opencode-magi 0.10.0 → 0.12.0

package/dist/tools/review/reviewer.js

@@ -0,0 +1,409 @@
+import { MagiError } from "@/magi";
+import { Prompt } from "@/prompts";
+import { filterEmpty, marker, omitNullish, retry, toTitleCase, Worker, } from "@/utils";
+export async function review() {
+    this.context.abort.throwIfAborted();
+    await this.updateEvent(`Reviewing.`);
+    if (!this.config.review.reviewers?.length)
+        throw new MagiError("blocked", "No reviewers configured.");
+    const worker = new Worker(this.config.review.concurrency.reviewers);
+    const reviewers = Object.fromEntries(await Promise.all(this.config.review.reviewers.map(({ account, id, persona }) => worker.run(async () => {
+        if (!this.state.pr?.metadata)
+            throw new MagiError("blocked", "PR metadata not found.");
+        if (!this.state.worktree)
+            throw new MagiError("blocked", "PR worktree not found.");
+        if (!this.state.pr.checks)
+            throw new MagiError("blocked", "PR checks not found.");
+        if (!this.state.pr.threads)
+            throw new MagiError("blocked", "PR threads not found.");
+        if (!this.state.reviewers)
+            throw new MagiError("blocked", "Reviewers not found.");
+        const { outputs, review, sessionId, status } = this.state.reviewers[id];
+        if (status === "skip") {
+            await this.updateEvent(`Skipping review with reviewer ${id}.`);
+            return [id, {}];
+        }
+        else {
+            if (!sessionId)
+                throw new MagiError("blocked", `No session ID found for reviewer ${id}.`);
+            if (status === "rereview" && !review?.commit_id)
+                throw new MagiError("blocked", `Missing previous review commit for reviewer ${id}.`);
+            const rereview = status !== "initial";
+            const label = rereview ? "rereview" : "review";
+            const cycle = (outputs?.length ?? 0) + 1;
+            await this.updateEvent(`Running ${label} with reviewer ${id}.`);
+            const sha = rereview
+                ? (review?.commit_id ?? this.state.pr.metadata.base.sha)
+                : this.state.pr.metadata.base.sha;
+            const inlineCommentTargets = this.state.pr.inlineCommentTargets?.[sha] ?? {};
+            const failedChecks = this.state.pr.checks.failed.filter(({ scope }) => scope);
+            const unresolvedThreads = this.state.pr.threads.filter(({ comments, isResolved }) => {
+                if (isResolved)
+                    return false;
+                if (this.config.mode === "single")
+                    return comments.some(({ body }) => {
+                        const markers = marker.parse(body);
+                        const { reviewer } = markers[0] ?? {};
+                        return reviewer === id;
+                    });
+                else
+                    return comments.some(({ author }) => author?.login === account);
+            });
+            const reviewContext = JSON.stringify(omitNullish({
+                checks: this.state.pr.checks,
+                comments: this.state.pr.comments,
+                files: this.state.pr.files,
+                issues: this.state.pr.issues,
+                metadata: this.state.pr.metadata,
+                threads: this.state.pr.threads,
+            }), null, 2);
+            const tags = [
+                "output_contract",
+                ["review", reviewContext],
+            ];
+            if (review) {
+                const previousReviewContext = JSON.stringify(omitNullish({
+                    body: review.body || undefined,
+                    commitId: review.commit_id,
+                    state: review.state,
+                    submittedAt: review.submitted_at,
+                }), null, 2);
+                tags.push(["previous_review", previousReviewContext]);
+            }
+            tags.push([
+                "unresolved_threads",
+                JSON.stringify(unresolvedThreads, null, 2),
+            ]);
+            if (failedChecks.length) {
+                const ciFailureContext = JSON.stringify(failedChecks, null, 2);
+                tags.push(["ci_failure", ciFailureContext]);
+            }
+            if (persona)
+                tags.push(["persona", persona]);
+            const prompt = await Prompt.init(this.magi, this.config, `review/${rereview ? "rereview" : "review"}`);
+            const taskMessage = await prompt.create(!rereview
+                ? this.config.review.prompts?.review
+                : this.config.review.prompts?.rereview, tags, omitNullish({
+                baseSha: this.state.pr.metadata.base.sha,
+                headSha: this.state.pr.metadata.head.sha,
+                owner: this.config.github.owner,
+                pr: this.number.toString(),
+                previousHeadSha: rereview
+                    ? (review?.commit_id ?? this.state.pr.metadata.head.sha)
+                    : undefined,
+                repo: this.config.github.repo,
+                worktreePath: this.state.worktree.path,
+            }));
+            const output = await retry(async (count, e) => {
+                const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
+                await this.createAgentFile(rereview ? "rereview" : "review", id, raw, count, cycle);
+                const parsed = prompt.parse(raw);
+                if (!prompt.validate(parsed))
+                    throw new Error(`Invalid output for reviewer ${id}.`);
+                validateThreadTargets(parsed, unresolvedThreads);
+                validateInlineCommentTargets(status, parsed, inlineCommentTargets);
+                const findings = parsed.findings ?? parsed.newFindings ?? [];
+                await this.updateEvent(filterEmpty([
+                    `Finished ${label} with reviewer ${id}.`,
+                    `Verdict: ${toTitleCase(parsed.verdict.toLocaleLowerCase())}.`,
+                    parsed.comment ? `Comment:\n${parsed.comment}` : undefined,
+                    findings.length
+                        ? `Findings:\n${findings
+                            .map(({ body, line, path, startLine }) => `- ${path}:${startLine != null ? `${startLine}-` : ""}${line}: ${body}`)
+                            .join("\n")}`
+                        : undefined,
+                    parsed.followUps?.length
+                        ? `FollowUps:\n${parsed.followUps
+                            .map(({ body, commentId }) => `- Comment ${commentId}: ${body}`)
+                            .join("\n")}`
+                        : undefined,
+                    parsed.resolves?.length
+                        ? `Resolved threads:\n${parsed.resolves
+                            .map(({ commentId, threadId }) => `- Comment ${commentId} in thread ${threadId}`)
+                            .join("\n")}`
+                        : undefined,
+                ]).join("\n\n"));
+                return parsed;
+            }, {
+                error: async (e, count) => {
+                    if (e instanceof MagiError)
+                        throw e;
+                    await this.updateEvent(`Attempt ${count} failed to ${label} with reviewer ${id}. Retrying...`);
+                },
+                retries: this.config.output.repairAttempts,
+                signal: this.context.abort,
+            });
+            if (!output)
+                throw new MagiError("blocked", `Invalid output for reviewer ${id}.`);
+            output.findings = output.findings?.map((finding) => ({
+                ...finding,
+                state: "accepted",
+            }));
+            return [id, { outputs: [...(outputs ?? []), output] }];
+        }
+    }))));
+    await this.updateState({ reviewers });
+    await this.updateEvent(`Finished reviewing.`);
+}
+export async function validateFindings() {
+    this.context.abort.throwIfAborted();
+    if (!this.config.review.reviewers?.length)
+        throw new MagiError("blocked", "No reviewers configured.");
+    if (!this.state.reviewers)
+        throw new MagiError("blocked", "Reviewers not found.");
+    const findings = Object.entries(this.state.reviewers).flatMap(([reviewer, { outputs }]) => {
+        const output = outputs?.at(-1);
+        if (output?.verdict !== "CHANGES_REQUESTED")
+            return [];
+        return (output.findings ?? output.newFindings ?? []).map((finding, index) => ({ finding, index, reviewer }));
+    });
+    if (!findings.length)
+        return;
+    await this.updateEvent(`Validating review findings.`);
+    const accepted = await collectAcceptedFindings.call(this, findings);
+    const reviewers = Object.fromEntries(Object.entries(this.state.reviewers ?? {}).map(([id, reviewer]) => [
+        id,
+        transformState(reviewer, id, accepted),
+    ]));
+    await notifyVerdictChanges.call(this, this.state.reviewers ?? {}, reviewers, "after majority finding validation");
+    await this.updateState({ reviewers });
+    await this.updateEvent(`Finished validating review findings.`);
+}
+export async function reconsiderClose() {
+    this.context.abort.throwIfAborted();
+    if (this.config.review.merge.approvalPolicy !== "unanimous")
+        return;
+    if (!this.config.review.reviewers?.length)
+        throw new MagiError("blocked", "No reviewers configured.");
+    if (!this.state.reviewers)
+        throw new MagiError("blocked", "Reviewers not found.");
+    const threshold = Math.floor(this.config.review.reviewers.length / 2) + 1;
+    const targetReviewers = Object.entries(this.state.reviewers).filter(([, { outputs }]) => outputs?.at(-1)?.verdict === "CLOSED");
+    const count = targetReviewers.length;
+    if (!count || count >= threshold)
+        return;
+    await this.updateEvent(`Reconsidering close verdicts.`);
+    const worker = new Worker(this.config.review.concurrency.reviewers);
+    const prompt = await Prompt.init(this.magi, this.config, "review/close-reconsideration");
+    const reviewers = Object.fromEntries(await Promise.all(targetReviewers.map(([id, { outputs, review, sessionId, status }]) => worker.run(async () => {
+        if (!this.state.pr?.metadata)
+            throw new MagiError("blocked", "PR metadata not found.");
+        if (!sessionId)
+            throw new MagiError("blocked", `No session ID found for reviewer ${id}.`);
+        if (status === "rereview" && !review?.commit_id)
+            throw new MagiError("blocked", `Missing previous review commit for reviewer ${id}.`);
+        const cycle = (outputs?.length ?? 0) + 1;
+        const sha = status === "initial"
+            ? this.state.pr.metadata.base.sha
+            : (review?.commit_id ?? this.state.pr.metadata.base.sha);
+        const inlineCommentTargets = this.state.pr.inlineCommentTargets?.[sha] ?? {};
+        const taskMessage = await prompt.create(this.config.review.prompts?.closeReconsideration, ["output_contract"], {
+            owner: this.config.github.owner,
+            pr: this.number.toString(),
+            repo: this.config.github.repo,
+        });
+        await this.updateEvent(`Reconsidering close verdict with reviewer ${id}.`);
+        const output = await retry(async (count, e) => {
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
+            await this.createAgentFile("close-reconsideration", id, raw, count, cycle);
+            const parsed = prompt.parse(raw);
+            if (!prompt.validate(parsed))
+                throw new Error(`Invalid close reconsideration output for reviewer ${id}.`);
+            validateInlineCommentTargets("initial", parsed, inlineCommentTargets);
+            return parsed;
+        }, {
+            error: async (e, count) => {
+                if (e instanceof MagiError)
+                    throw e;
+                await this.updateEvent(`Attempt ${count} failed to reconsider close verdict with reviewer ${id}. Retrying...`);
+            },
+            retries: this.config.output.repairAttempts,
+            signal: this.context.abort,
+        });
+        if (!output)
+            throw new MagiError("blocked", `Invalid close reconsideration output for reviewer ${id}.`);
+        output.findings = output.findings?.map((finding) => ({
+            ...finding,
+            state: "accepted",
+        }));
+        return [id, { outputs: [...(outputs ?? []), output] }];
+    }))));
+    const findings = Object.entries(reviewers).flatMap(([reviewer, { outputs }]) => {
+        const output = outputs?.at(-1);
+        if (output?.verdict !== "CHANGES_REQUESTED")
+            return [];
+        return (output.findings ?? []).map((finding, index) => ({
+            finding,
+            index,
+            reviewer,
+        }));
+    });
+    await notifyVerdictChanges.call(this, this.state.reviewers ?? {}, reviewers, "after close reconsideration");
+    const accepted = await collectAcceptedFindings.call(this, findings);
+    const validatedReviewers = Object.fromEntries(Object.entries(reviewers).map(([id, reviewer]) => [
+        id,
+        transformState(reviewer, id, accepted),
+    ]));
+    await notifyVerdictChanges.call(this, reviewers, validatedReviewers, "after majority finding validation");
+    await this.updateState({ reviewers: validatedReviewers });
+    await this.updateEvent(`Finished reconsidering close verdicts.`);
+}
+async function collectAcceptedFindings(findings) {
+    const accepted = new Set();
+    if (!findings.length)
+        return accepted;
+    if (!this.config.review.reviewers?.length)
+        throw new MagiError("blocked", "No reviewers configured.");
+    if (!this.state.reviewers)
+        throw new MagiError("blocked", "Reviewers not found.");
+    const worker = new Worker(this.config.review.concurrency.reviewers);
+    const prompt = await Prompt.init(this.magi, this.config, "review/finding-validation");
+    const validations = Object.fromEntries(await Promise.all(this.config.review.reviewers.map(({ id }) => worker.run(async () => {
+        const { sessionId } = this.state.reviewers[id];
+        if (!sessionId)
+            throw new MagiError("blocked", `No session ID found for reviewer ${id}.`);
+        await this.updateEvent(`Validating review findings with reviewer ${id}.`);
+        const targetFindings = findings.filter((target) => target.reviewer !== id);
+        const expectedKeys = new Set(targetFindings.map(({ index, reviewer }) => `${reviewer}:${index}`));
+        const taskMessage = await prompt.create(this.config.review.prompts?.findingValidation, [
+            "output_contract",
+            ["findings", JSON.stringify(targetFindings, null, 2)],
+        ], {
+            owner: this.config.github.owner,
+            pr: this.number.toString(),
+            repo: this.config.github.repo,
+        });
+        const output = await retry(async (count, e) => {
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
+            await this.createAgentFile("finding-validation", id, raw, count);
+            const parsed = prompt.parse(raw);
+            if (!prompt.validate(parsed))
+                throw new Error(`Invalid finding validation output for reviewer ${id}.`);
+            const seen = new Set();
+            for (const vote of parsed.votes) {
+                if (vote.reviewer === id)
+                    throw new Error(`${id} must not vote on its own findings.`);
+                const key = `${vote.reviewer}:${vote.index}`;
+                if (!expectedKeys.has(key))
+                    throw new Error(`Unexpected finding vote: ${key}.`);
+                if (seen.has(key))
+                    throw new Error(`Duplicate finding vote: ${key}.`);
+                seen.add(key);
+            }
+            for (const key of expectedKeys)
+                if (!seen.has(key))
+                    throw new Error(`Missing finding vote: ${key}.`);
+            return parsed;
+        }, {
+            error: async (e, count) => {
+                if (e instanceof MagiError)
+                    throw e;
+                await this.updateEvent(`Attempt ${count} failed to validate review findings with reviewer ${id}. Retrying...`);
+            },
+            retries: this.config.output.repairAttempts,
+            signal: this.context.abort,
+        });
+        if (!output)
+            throw new MagiError("blocked", `Invalid finding validation output for reviewer ${id}.`);
+        return [id, output];
+    }))));
+    const threshold = Math.floor(this.config.review.reviewers.length / 2) + 1;
+    await Promise.all(findings.map(async ({ finding, index, reviewer }) => {
+        const votes = Object.entries(validations).flatMap(([validator, validation]) => {
+            if (validator === reviewer)
+                return [];
+            const vote = validation.votes.find((vote) => vote.reviewer === reviewer && vote.index === index);
+            return vote ? [{ validator, vote }] : [];
+        });
+        const agrees = 1 + votes.filter(({ vote }) => vote.vote === "AGREE").length;
+        const key = `${reviewer}:${index}`;
+        const acceptedComments = votes
+            .filter(({ vote }) => vote.vote === "AGREE")
+            .map(({ validator, vote }) => `- ${validator}: ${vote.comment}`);
+        const rejectedComments = votes
+            .filter(({ vote }) => vote.vote === "DISAGREE")
+            .map(({ validator, vote }) => `- ${validator}: ${vote.comment}`);
+        if (agrees >= threshold)
+            accepted.add(key);
+        await this.updateEvent(filterEmpty([
+            `Finding ${reviewer} #${index + 1} was ${agrees >= threshold ? "accepted" : "rejected"} by majority vote.`,
+            `Finding: ${finding.path}:${finding.line}\n${finding.body}`,
+            acceptedComments.length
+                ? `Accepted by:\n${acceptedComments.join("\n")}`
+                : undefined,
+            rejectedComments.length
+                ? `Rejected by:\n${rejectedComments.join("\n")}`
+                : undefined,
+        ]).join("\n\n"));
+    }));
+    return accepted;
+}
+function transformState(reviewer, id, accepted) {
+    const outputs = [...(reviewer.outputs ?? [])];
+    const prevOutput = outputs[outputs.length - 1];
+    if (prevOutput?.verdict !== "CHANGES_REQUESTED")
+        return reviewer;
+    const nextOutput = { ...prevOutput };
+    const findings = (prevOutput.findings ??
+        prevOutput.newFindings ??
+        []).map((finding, index) => ({
+        ...finding,
+        state: accepted.has(`${id}:${index}`) ? "accepted" : "discarded",
+    }));
+    if (prevOutput.findings)
+        nextOutput.findings = findings;
+    else if (prevOutput.newFindings)
+        nextOutput.newFindings = findings;
+    outputs[outputs.length - 1] = nextOutput;
+    if (!findings.some(({ state }) => state === "accepted"))
+        outputs.push({ verdict: "APPROVED" });
+    return { ...reviewer, outputs };
+}
+async function notifyVerdictChanges(prev, next, reason) {
+    await Promise.all(Object.entries(next).map(async ([id, reviewer]) => {
+        const prevVerdict = prev[id]?.outputs?.at(-1)?.verdict;
+        const nextVerdict = reviewer.outputs?.at(-1)?.verdict;
+        if (!prevVerdict || !nextVerdict || prevVerdict === nextVerdict)
+            return;
+        await this.updateEvent(`Reviewer ${id} verdict changed from ${toTitleCase(prevVerdict.toLocaleLowerCase())} to ${toTitleCase(nextVerdict.toLocaleLowerCase())} ${reason}.`);
+    }));
+}
+function validateInlineCommentTargets(status, output, inlineCommentTargets) {
+    const target = status === "initial" ? "findings" : "newFindings";
+    const findings = output[target] ?? [];
+    for (const [index, finding] of findings.entries()) {
+        const name = `${target}[${index}]`;
+        if (!Number.isInteger(finding.line) || finding.line < 1)
+            throw new Error(`${name}.line must be a positive integer.`);
+        if (finding.startLine != null) {
+            if (!Number.isInteger(finding.startLine) || finding.startLine < 1)
+                throw new Error(`${name}.startLine must be a positive integer.`);
+            if (finding.startLine > finding.line)
+                throw new Error(`${name}.startLine must be before or equal to ${name}.line.`);
+        }
+        const lines = inlineCommentTargets[finding.path];
+        if (!lines) {
+            throw new Error(`${name} targets ${finding.path}:${finding.line}, but path is not in the PR diff.`);
+        }
+        else {
+            const startLine = finding.startLine ?? finding.line;
+            for (let line = startLine; line <= finding.line; line++)
+                if (!lines.includes(line))
+                    throw new Error(`${name} targets ${finding.path}:${line}, but line is not in a right-side PR diff hunk.`);
+        }
+    }
+}
+function validateThreadTargets({ followUps, resolves }, threads) {
+    const targets = new Map(threads.flatMap(({ comments, id }) => comments.flatMap(({ databaseId }) => databaseId == null ? [] : [[databaseId, id]])));
+    const allowedTargets = [...targets.entries()]
+        .map(([commentId, threadId]) => `- ${commentId}:${threadId}`)
+        .join("\n") || "none";
+    if (followUps)
+        for (const [index, { commentId }] of followUps.entries())
+            if (!targets.has(commentId))
+                throw new Error(`followUps[${index}].commentId must target an unresolved thread owned by the reviewer.\n\nAllowed targets:\n${allowedTargets}`);
+    if (resolves)
+        for (const [index, { commentId, threadId }] of resolves.entries())
+            if (targets.get(commentId) !== threadId)
+                throw new Error(`resolves[${index}] must target an unresolved thread owned by the reviewer.\n\nAllowed targets:\n${allowedTargets}`);
+}

package/dist/tools/triage/index.js

@@ -0,0 +1,16 @@
+import { tool } from "@opencode-ai/plugin";
+export const triage = function (magi) {
+    return {
+        magi_triage: tool({
+            args: {
+                dryRun: tool.schema.boolean().optional(),
+                issues: tool.schema.string(),
+            },
+            description: "Triage one or more issues with configured Magi triage voters.",
+            async execute({ dryRun: _dryRun = false, issues: _issues }) {
+                const _config = await magi.getConfig({ creator: true, voters: true });
+                return "";
+            },
+        }),
+    };
+};

package/dist/tools/validate/index.js

@@ -0,0 +1,28 @@
+import { tool } from "@opencode-ai/plugin";
+import { getConfig, validateConfig } from "@/config";
+function createReport(errors) {
+    return [
+        `Magi config validation: ${errors.length ? "failed" : "passed"}`,
+        "",
+        "Errors:",
+        ...(errors.length ? errors.map((message) => `- ${message}`) : ["- None"]),
+    ].join("\n");
+}
+export const validate = function (magi) {
+    return {
+        magi_validate: tool({
+            args: {},
+            description: "Validate global and project Magi config presence, merged settings, reviewer rules, model IDs, and account authentication.",
+            async execute() {
+                try {
+                    const config = await getConfig(magi.input);
+                    const errors = await validateConfig(config, { exec: magi.exec });
+                    return createReport(errors);
+                }
+                catch (e) {
+                    return createReport([e.message]);
+                }
+            },
+        }),
+    };
+};

package/dist/utils/array.js

@@ -0,0 +1,6 @@
+export function filterDuplicates(value) {
+    return [...new Set(value)];
+}
+export function filterEmpty(array) {
+    return array.filter((value) => value != null);
+}

package/dist/utils/assertion.js

@@ -0,0 +1,38 @@
+export function isNumber(value) {
+    return typeof value === "number";
+}
+export function isString(value) {
+    return Object.prototype.toString.call(value) === "[object String]";
+}
+export function isBoolean(value) {
+    return typeof value === "boolean";
+}
+export function isUndefined(value) {
+    return typeof value === "undefined";
+}
+export function isNull(value) {
+    return value === null;
+}
+export function isRegExp(value) {
+    return value instanceof RegExp;
+}
+export function isObject(value) {
+    return (value != null &&
+        (typeof value === "object" || typeof value === "function") &&
+        !isArray(value));
+}
+export function isDate(value) {
+    return value instanceof Date;
+}
+export function isArray(value) {
+    return Array.isArray(value);
+}
+export function isEmpty(value) {
+    return !isArray(value) || !value.length || value.every((v) => v == null);
+}
+export function isEmptyObject(value) {
+    return isObject(value) && !Object.keys(value).length;
+}
+export function isFunction(value) {
+    return typeof value === "function";
+}

package/dist/utils/exec.js

@@ -0,0 +1,14 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+export const execAsync = promisify(exec);
+export function createExec(defaultCwd) {
+    return async function (command, { cwd, env, signal } = {}) {
+        const { stdout } = await execAsync(command, {
+            cwd: cwd ?? defaultCwd,
+            env: { ...process.env, ...env },
+            maxBuffer: 1024 * 1024 * 20,
+            signal,
+        });
+        return stdout.trim();
+    };
+}

package/dist/utils/fs.js

@@ -0,0 +1,24 @@
+import { rm as originalRm, readdir, rmdir } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { isString } from "./assertion";
+export async function rm(path, { prune, ...options } = {}) {
+    await originalRm(path, options);
+    if (!prune)
+        return;
+    const root = resolve(isString(prune) ? prune : process.cwd());
+    let dir = dirname(resolve(path));
+    while (dir !== root) {
+        const value = relative(root, dir);
+        if (!value || value.startsWith("..") || isAbsolute(value))
+            break;
+        try {
+            if ((await readdir(dir)).length)
+                break;
+            await rmdir(dir);
+        }
+        catch {
+            break;
+        }
+        dir = dirname(dir);
+    }
+}

package/dist/utils/function.js

@@ -0,0 +1,46 @@
+export function wait(ms = 0, signal) {
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            clearTimeout(timeout);
+            reject(signal?.reason);
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+export async function ignoreError(cb, shouldIgnore) {
+    try {
+        return await cb();
+    }
+    catch (e) {
+        if (!shouldIgnore(e))
+            throw e;
+    }
+}
+export async function loop(cb, ms = 0) {
+    for (;;) {
+        const value = await cb();
+        if (value != null)
+            return value;
+        await wait(ms);
+    }
+}
+export async function retry(cb, { error: errorCb, retries = 1, signal }) {
+    let count = 1;
+    let error;
+    while (count <= retries)
+        try {
+            signal?.throwIfAborted();
+            return await cb(count, error);
+        }
+        catch (e) {
+            signal?.throwIfAborted();
+            await errorCb?.(e, count);
+            error = e;
+            count += 1;
+        }
+}

package/dist/utils/github.js

@@ -0,0 +1,63 @@
+import { filterEmpty } from "./array";
+import { isObject } from "./assertion";
+export function parseIssues(value) {
+    const numbers = filterEmpty(value
+        .split(/[\s,]+/)
+        .map((item) => item.match(/(?:issues\/|#)?(\d+)$/)?.[1])).map(Number);
+    if (!numbers.length)
+        throw new Error("Specify one or more issue numbers or issue URLs.");
+    return numbers;
+}
+export function parsePrs(value) {
+    let options = false;
+    const numbers = filterEmpty(value.split(/[\s,]+/).map((item) => {
+        if (item.startsWith("--"))
+            options = true;
+        if (options)
+            return;
+        return item.match(/(?:pull\/|#)?(\d+)$/)?.[1];
+    })).map(Number);
+    if (!numbers.length)
+        throw new Error("Specify one or more PR numbers or PR URLs.");
+    return numbers;
+}
+function getErrorMessage(e) {
+    if (!e || !isObject(e))
+        return String(e);
+    const value = e;
+    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(e) {
+    return /rate limit/i.test(getErrorMessage(e));
+}
+export function createExecWithGitHubApiRetry(exec, retryAttempts, delay = 1_000) {
+    return async (command, options) => {
+        for (let attempt = 0;; attempt += 1)
+            try {
+                return await exec(command, options);
+            }
+            catch (e) {
+                if (attempt >= retryAttempts ||
+                    !isGitHubCommand(command) ||
+                    !isRateLimitError(e))
+                    throw e;
+                const ms = delay * 2 ** attempt;
+                if (0 < ms) {
+                    if (options?.signal?.aborted)
+                        throw new DOMException("Aborted", "AbortError");
+                    await new Promise((resolve, reject) => {
+                        const timeout = setTimeout(resolve, ms);
+                        options?.signal?.addEventListener("abort", () => {
+                            clearTimeout(timeout);
+                            reject(new DOMException("Aborted", "AbortError"));
+                        }, { once: true });
+                    });
+                }
+            }
+    };
+}

package/dist/utils/index.js

@@ -0,0 +1,10 @@
+export * from "./array";
+export * from "./assertion";
+export * from "./exec";
+export * from "./fs";
+export * from "./function";
+export * from "./github";
+export * from "./object";
+export * from "./opencode";
+export * from "./string";
+export * from "./worker";

package/dist/utils/index.type.js

@@ -0,0 +1 @@
+export {};