opencode-magi 0.5.0 → 0.6.1

package/dist/config/resolve.js

@@ -28,7 +28,7 @@ export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
 export function triageAgentKey(agent, index) {
-    return agent.id ?? `triage-${index + 1}`;
+    return agent.id ?? `voter-${index + 1}`;
 }
 export function validateReviewerId(id) {
     return ID_PATTERN.test(id);
@@ -104,7 +104,7 @@ export function resolveAgents(config) {
         triageCreator: creator
             ? {
                 ...creator,
-                account: creator.account ?? config.triage?.account ?? "",
+                account: creator.account ?? "",
                 permission: resolveTriageCreatorPermission(agents, creator),
             }
             : undefined,
@@ -179,7 +179,6 @@ export function resolveRepository(config) {
             requiredLabels: config.review?.safety?.requiredLabels ?? [],
         },
         triage: {
-            account: config.triage?.account,
             automation: {
                 clear: config.triage?.automation?.clear ?? ["triage"],
                 close: config.triage?.automation?.close ?? false,
@@ -193,6 +192,7 @@ export function resolveRepository(config) {
             },
             output: config.triage?.output,
             prompts: config.triage?.prompts ?? {},
+            reporter: config.triage?.reporter,
             safety: {
                 allowAuthors: config.triage?.safety?.allowAuthors ?? [],
                 allowMentionActors: config.triage?.safety?.allowMentionActors ?? [],

package/dist/config/validate.js

@@ -40,6 +40,7 @@ const EDITOR_KEYS = new Set([
     "persona",
 ]);
 const TRIAGE_AGENT_KEYS = new Set([
+    "account",
     "id",
     "model",
     "options",
@@ -75,7 +76,6 @@ const MERGE_KEYS = new Set([
     "prompts",
 ]);
 const TRIAGE_KEYS = new Set([
-    "account",
     "agents",
     "automation",
     "categories",
@@ -83,6 +83,7 @@ const TRIAGE_KEYS = new Set([
     "creator",
     "output",
     "prompts",
+    "reporter",
     "safety",
     "worktree",
 ]);
@@ -135,16 +136,13 @@ const MERGE_PROMPT_KEYS = new Set([
     "editGuidelines",
 ]);
 const TRIAGE_PROMPT_KEYS = new Set([
-    "action",
     "acceptance",
     "category",
-    "comment",
     "commentClassification",
     "create",
     "createGuidelines",
     "duplicate",
     "existingPr",
-    "question",
     "reconsider",
 ]);
 function githubHost(config) {
@@ -357,6 +355,9 @@ function validateTriageAgentList(agents, path, errors, catalog) {
             errors.push(`${path}[${index}].model is required`);
         validateString(agent.model, `${path}[${index}].model`, errors);
         validateModel(agent.model, `${path}[${index}].model`, errors, catalog);
+        if (!agent.account)
+            errors.push(`${path}[${index}].account is required`);
+        validateString(agent.account, `${path}[${index}].account`, errors);
         validateString(agent.persona, `${path}[${index}].persona`, errors);
         if (agent.options != null && !isPlainObject(agent.options))
             errors.push(`${path}[${index}].options must be an object`);
@@ -383,12 +384,16 @@ function validateResolvedReviewers(reviewers, path, errors) {
         accounts.add(reviewer.account);
     }
 }
-function validateResolvedAgentKeys(agents, path, errors) {
+function validateResolvedTriageAgents(agents, path, errors) {
     const keys = new Set();
+    const accounts = new Set();
     for (const agent of agents) {
         if (keys.has(agent.key))
             errors.push(`${path} has duplicate agent key: ${agent.key}`);
         keys.add(agent.key);
+        if (accounts.has(agent.account))
+            errors.push(`${path} has duplicate agent account: ${agent.account}`);
+        accounts.add(agent.account);
     }
 }
 function validateEditor(editor, path, errors, catalog) {
@@ -672,19 +677,26 @@ function validateTriage(config, errors, options) {
     validateKnownKeys(triage, "triage", TRIAGE_KEYS, errors);
     const automation = triage.automation;
     const concurrency = triage.concurrency;
+    const creator = triage.creator;
+    const reporter = typeof triage.reporter === "string" ? triage.reporter : undefined;
     const safety = triage.safety;
-    if (!triage.account)
-        errors.push("triage.account is required");
-    validateString(triage.account, "triage.account", errors);
     if (!triage.agents)
         errors.push("triage.agents is required");
     validateTriageAgentList(triage.agents, "triage.agents", errors, options.modelCatalog);
     if (Array.isArray(triage.agents)) {
-        validateResolvedAgentKeys(resolveAgents(config).triage ?? [], "triage.resolvedAgents", errors);
+        const resolvedTriageAgents = resolveAgents(config).triage ?? [];
+        validateResolvedTriageAgents(resolvedTriageAgents, "triage.resolvedAgents", errors);
+        if (reporter != null &&
+            !resolvedTriageAgents.some((agent) => agent.key === reporter)) {
+            errors.push(`triage.reporter must match a triage agent key: ${reporter}`);
+        }
     }
-    validateTriageCreator(triage.creator, "triage.creator", errors, options.modelCatalog);
-    if (automation?.create && !triage.creator)
+    validateString(triage.reporter, "triage.reporter", errors);
+    validateTriageCreator(creator, "triage.creator", errors, options.modelCatalog);
+    if (automation?.create && !creator)
         errors.push("triage.creator is required when triage.automation.create is true");
+    if (automation?.create && creator && !creator.account)
+        errors.push("triage.creator.account is required when triage.automation.create is true");
     if (automation != null && !isPlainObject(automation)) {
         errors.push("triage.automation must be an object");
     }
@@ -745,10 +757,10 @@ async function validateAuth(config, exec, errors) {
     const agents = resolveAgents(config);
     for (const reviewer of agents.reviewers)
         accounts.add(reviewer.account);
+    for (const agent of agents.triage ?? [])
+        accounts.add(agent.account);
     if (agents.editor)
         accounts.add(agents.editor.account);
-    if (config.triage?.account)
-        accounts.add(config.triage.account);
     if (agents.triageCreator?.account)
         accounts.add(agents.triageCreator.account);
     await Promise.all([...accounts].filter(Boolean).map(async (account) => {
@@ -802,19 +814,18 @@ async function validateRepositoryPermissions(config, exec, errors, warnings) {
             warnings.push(`Could not validate repository permissions for GitHub account: ${reviewer.account} (${error.message})`);
         }
     }));
-    if (config.triage?.account) {
+    await Promise.all((agents.triage ?? []).map(async (agent) => {
         try {
-            const permissions = await fetchPermissions(config, exec, config.triage.account);
+            const permissions = await fetchPermissions(config, exec, agent.account);
             if (!permissions.pull) {
-                errors.push(`GitHub account cannot read repository for issue triage: ${config.triage.account}`);
+                errors.push(`GitHub account cannot read repository for issue triage: ${agent.account}`);
             }
         }
         catch (error) {
-            warnings.push(`Could not validate repository permissions for GitHub account: ${config.triage.account} (${error.message})`);
+            warnings.push(`Could not validate repository permissions for GitHub account: ${agent.account} (${error.message})`);
         }
-    }
-    if (agents.triageCreator?.account &&
-        agents.triageCreator.account !== config.triage?.account) {
+    }));
+    if (agents.triageCreator?.account) {
         try {
             const permissions = await fetchPermissions(config, exec, agents.triageCreator.account);
             if (!permissions.push) {

package/dist/config/worktree.js

@@ -17,3 +17,9 @@ export function worktreeBaseDirs(directory, config = {}) {
         worktreeBaseDir(directory, config, "issue"),
     ];
 }
+export function prRunWorktreeDir(input) {
+    return join(worktreeBaseDir(input.directory, input.config, "pr"), String(input.pr), input.runId);
+}
+export function issueRunWorktreeDir(input) {
+    return join(worktreeBaseDir(input.directory, input.config, "issue"), String(input.issue), input.runId);
+}

package/dist/github/commands.js

@@ -20,6 +20,82 @@ function errorText(error) {
         .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) ||
@@ -122,26 +198,34 @@ export async function fetchPullRequestClosingIssues(exec, repository, pr) {
 }
 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 {
-        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,
-        };
+        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 {
-        return fetchIssueWithCli(exec, repository, 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`);
@@ -330,16 +414,43 @@ export async function removeIssueLabels(exec, repository, issue, labels, account
     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}`);
-    const data = JSON.parse(raw);
-    return data.data.repository.pullRequest.reviews.nodes;
+    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!) { 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 }) => ({
+    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,
@@ -369,37 +480,9 @@ export async function fetchPullRequestSafetyMeta(exec, repository, pr) {
     }
     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 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";
@@ -409,8 +492,9 @@ export function isFailedCheck(check) {
 }
 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`);
+        raw = await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json name,state,bucket,link,workflow${requiredFlag}`);
     }
     catch (error) {
         if (options.tolerateMissingChecks &&
@@ -472,9 +556,8 @@ export async function fetchMergeQueueRequirement(exec, repository, branch) {
     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}`;
+export async function createWorktree(exec, repository, pr, worktreePath) {
+    const lockKey = `${repoSpecifier(repository)}:${dirname(dirname(worktreePath))}`;
     return withWorktreeCreateLock(lockKey, async () => {
         let worktreeAdded = false;
         try {
@@ -591,6 +674,17 @@ export async function waitForMergeQueue(exec, repository, pr, intervalMs = 30_00
         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 closePullRequest(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`, ghTokenEnv(token));
@@ -629,11 +723,49 @@ export async function configureGitIdentity(exec, worktreePath, identity) {
     }
 }
 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;
+    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 [];

package/dist/index.js

@@ -96,6 +96,7 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
     const configOverrides = {};
     const prTokens = [];
     let sync = false;
+    let timeoutMs;
     for (let index = 0; index < tokens.length; index++) {
         const token = tokens[index];
         if (token === "--dry-run") {
@@ -110,6 +111,11 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
             case "--language":
                 setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
                 break;
+            case "--timeout":
+                timeoutMs =
+                    parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 0) *
+                        1_000;
+                break;
             case "--merge":
             case "--no-merge":
                 setConfigOverride(configOverrides, [command, "automation", "merge"], token === "--merge");
@@ -151,13 +157,20 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
                 prTokens.push(token);
         }
     }
-    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")), sync };
+    return {
+        configOverrides,
+        dryRun,
+        prs: parsePrs(prTokens.join(" ")),
+        sync,
+        timeoutMs,
+    };
 }
 export function parseIssueRunArguments(value, dryRun = false) {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
     const configOverrides = {};
     const issueTokens = [];
     let sync = false;
+    let timeoutMs;
     for (let index = 0; index < tokens.length; index++) {
         const token = tokens[index];
         if (token === "--dry-run") {
@@ -172,6 +185,11 @@ export function parseIssueRunArguments(value, dryRun = false) {
             case "--language":
                 setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
                 break;
+            case "--timeout":
+                timeoutMs =
+                    parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 0) *
+                        1_000;
+                break;
             case "--close":
             case "--no-close":
                 setConfigOverride(configOverrides, ["triage", "automation", "close"], token === "--close");
@@ -210,6 +228,7 @@ export function parseIssueRunArguments(value, dryRun = false) {
         dryRun,
         issues: parseIssues(issueTokens.join(" ")),
         sync,
+        timeoutMs,
     };
 }
 function nextFlagValue(tokens, index, flag) {
@@ -306,6 +325,10 @@ function prMarkdownLink(repository, pr) {
     const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/pull/${pr}`;
     return `[#${pr}](${url})`;
 }
+export function formatRunStartMessage(command, repository, pr) {
+    const action = command === "merge" ? "merge flow" : "reviewing";
+    return `Started ${action} ${prMarkdownLink(repository, pr)}.`;
+}
 function issueMarkdownLink(repository, issue) {
     const host = repository.github.host || "github.com";
     const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/issues/${issue}`;
@@ -482,11 +505,12 @@ export const MagiPlugin = async ({ client, directory }) => {
                         parentSessionId: context.sessionID,
                         signal: context.abort,
                         sync,
+                        timeoutMs: parsed.timeoutMs,
                     }), { signal: context.abort });
                     if (sync)
                         return syncResult(runManager, states);
                     return states
-                        .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
+                        .map((state) => formatRunStartMessage("merge", repository, state.pr))
                         .join("\n");
                 },
             }),
@@ -523,11 +547,12 @@ export const MagiPlugin = async ({ client, directory }) => {
                         parentSessionId: context.sessionID,
                         signal: context.abort,
                         sync,
+                        timeoutMs: parsed.timeoutMs,
                     }), { signal: context.abort });
                     if (sync)
                         return syncResult(runManager, states);
                     return states
-                        .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
+                        .map((state) => formatRunStartMessage("review", repository, state.pr))
                         .join("\n");
                 },
             }),
@@ -567,6 +592,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                         repository,
                         signal: context.abort,
                         sync,
+                        timeoutMs: parsed.timeoutMs,
                     }), { signal: context.abort });
                     if (sync)
                         return syncResult(runManager, states);