opencode-magi 0.0.0-dev-20260519144738 → 0.0.0-dev-20260520030110

package/README.md

@@ -149,6 +149,8 @@ Run commands from OpenCode.
 /magi:review --dry-run 123
 /magi:merge 123
 /magi:merge --dry-run 123
+/magi:triage 47 48
+/magi:triage --dry-run 47
 /magi:clear
 ```
 

package/dist/commands.js

@@ -7,6 +7,10 @@ export const MAGI_COMMANDS = {
         description: "Review and merge pull requests with Magi",
         template: [`Call the \`magi_merge\` tool.`, "PR: $ARGUMENTS"].join("\n"),
     },
+    "magi:triage": {
+        description: "Triage GitHub issues with Magi",
+        template: [`Call the \`magi_triage\` tool.`, "Issue: $ARGUMENTS"].join("\n"),
+    },
     "magi:review": {
         description: "Review pull requests with Magi",
         template: [`Call the \`magi_review\` tool.`, "PR: $ARGUMENTS"].join("\n"),

package/dist/config/output.js

@@ -1,16 +1,25 @@
 import { isAbsolute, join } from "node:path";
 const DEFAULT_OUTPUT_DIRS = {
+    issue: ".magi/runs/issue",
     pr: ".magi/runs/pr",
 };
 function resolvePath(directory, path) {
     return isAbsolute(path) ? path : join(directory, path);
 }
 export function outputBaseDir(directory, config, kind) {
-    return resolvePath(directory, config.review?.output ?? DEFAULT_OUTPUT_DIRS[kind]);
+    return resolvePath(directory, kind === "issue"
+        ? (config.triage?.output ?? DEFAULT_OUTPUT_DIRS[kind])
+        : (config.review?.output ?? DEFAULT_OUTPUT_DIRS[kind]));
 }
 export function outputBaseDirs(directory, config) {
-    return [outputBaseDir(directory, config, "pr")];
+    return [
+        outputBaseDir(directory, config, "pr"),
+        outputBaseDir(directory, config, "issue"),
+    ];
 }
 export function prRunOutputDir(input) {
     return join(outputBaseDir(input.directory, input.config, "pr"), String(input.pr), ...(input.runId ? [input.runId] : []));
 }
+export function issueRunOutputDir(input) {
+    return join(outputBaseDir(input.directory, input.config, "issue"), String(input.issue), ...(input.runId ? [input.runId] : []));
+}

package/dist/config/resolve.js

@@ -7,6 +7,9 @@ const DEFAULT_EDITOR_PERMISSION = mergePermissions(DEFAULT_COMMON_PERMISSION, ed
 export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
+export function triageAgentKey(agent, index) {
+    return agent.id ?? `triage-${index + 1}`;
+}
 export function validateReviewerId(id) {
     return ID_PATTERN.test(id);
 }
@@ -49,9 +52,16 @@ export function resolveReviewerPermission(agents, reviewer) {
 export function resolveEditorPermission(agents, editor) {
     return mergePermissions(mergePermissions(DEFAULT_EDITOR_PERMISSION, agents.permissions), editor.permissions);
 }
+export function resolveTriageAgentPermission(agents, agent) {
+    return mergePermissions(mergePermissions(DEFAULT_REVIEWER_PERMISSION, agents.permissions), agent.permissions);
+}
+export function resolveTriageCreatorPermission(agents, creator) {
+    return mergePermissions(mergePermissions(DEFAULT_EDITOR_PERMISSION, agents.permissions), creator.permissions);
+}
 export function resolveAgents(config) {
     const agents = config.agents ?? {};
     const editor = config.merge?.editor;
+    const creator = config.triage?.creator;
     return {
         editor: editor
             ? {
@@ -65,6 +75,19 @@ export function resolveAgents(config) {
             index,
             permission: resolveReviewerPermission(agents, reviewer),
         })),
+        triage: (config.triage?.agents ?? []).map((agent, index) => ({
+            ...agent,
+            key: triageAgentKey(agent, index),
+            index,
+            permission: resolveTriageAgentPermission(agents, agent),
+        })),
+        triageCreator: creator
+            ? {
+                ...creator,
+                account: creator.account ?? config.triage?.account ?? "",
+                permission: resolveTriageCreatorPermission(agents, creator),
+            }
+            : undefined,
     };
 }
 export function resolveRepository(config) {
@@ -127,5 +150,41 @@ export function resolveRepository(config) {
             maxChangedFiles: config.review?.safety?.maxChangedFiles,
             requiredLabels: config.review?.safety?.requiredLabels ?? [],
         },
+        triage: {
+            account: config.triage?.account,
+            automation: {
+                clear: config.triage?.automation?.clear ?? ["triage"],
+                close: config.triage?.automation?.close ?? false,
+                pr: config.triage?.automation?.pr ?? false,
+            },
+            concurrency: {
+                runs: config.triage?.concurrency?.runs ?? 3,
+            },
+            kind: {
+                bug: {
+                    label: config.triage?.kind?.bug?.label ?? ["bug"],
+                    type: config.triage?.kind?.bug?.type ?? ["Bug"],
+                },
+                feature: {
+                    label: config.triage?.kind?.feature?.label ?? ["enhancement"],
+                    type: config.triage?.kind?.feature?.type ?? ["Feature"],
+                },
+            },
+            output: config.triage?.output,
+            prompts: config.triage?.prompts ?? {},
+            safety: {
+                allowAuthors: config.triage?.safety?.allowAuthors ?? [],
+                allowMentionActors: config.triage?.safety?.allowMentionActors ?? [],
+                allowMentionRoles: config.triage?.safety?.allowMentionRoles ?? [
+                    "AUTHOR",
+                    "OWNER",
+                    "MEMBER",
+                    "COLLABORATOR",
+                ],
+                blockedLabels: config.triage?.safety?.blockedLabels ?? [],
+                requiredLabels: config.triage?.safety?.requiredLabels ?? ["triage"],
+            },
+            worktree: config.triage?.worktree,
+        },
     };
 }

package/dist/config/validate.js

@@ -18,6 +18,7 @@ const CONFIG_KEYS = new Set([
     "merge",
     "output",
     "review",
+    "triage",
 ]);
 const AGENTS_KEYS = new Set(["permissions"]);
 const REVIEWER_KEYS = new Set([
@@ -36,6 +37,21 @@ const EDITOR_KEYS = new Set([
     "permissions",
     "persona",
 ]);
+const TRIAGE_AGENT_KEYS = new Set([
+    "id",
+    "model",
+    "options",
+    "permissions",
+    "persona",
+]);
+const TRIAGE_CREATOR_KEYS = new Set([
+    "account",
+    "author",
+    "model",
+    "options",
+    "permissions",
+    "persona",
+]);
 const AUTHOR_KEYS = new Set(["email", "name"]);
 const GITHUB_KEYS = new Set(["apiRetryAttempts", "host", "owner", "repo"]);
 const REVIEW_KEYS = new Set([
@@ -56,6 +72,18 @@ const MERGE_KEYS = new Set([
     "maxThreadResolutionCycles",
     "prompts",
 ]);
+const TRIAGE_KEYS = new Set([
+    "account",
+    "agents",
+    "automation",
+    "concurrency",
+    "creator",
+    "kind",
+    "output",
+    "prompts",
+    "safety",
+    "worktree",
+]);
 const REVIEW_MERGE_KEYS = new Set([
     "approvalPolicy",
     "auto",
@@ -69,6 +97,17 @@ const AUTOMATION_KEYS = new Set(["close", "merge"]);
 const CLEAR_KEYS = new Set(["branch", "output", "session", "worktree"]);
 const CONCURRENCY_KEYS = new Set(["reviewers", "runs"]);
 const OUTPUT_KEYS = new Set(["repairAttempts"]);
+const TRIAGE_AUTOMATION_KEYS = new Set(["clear", "close", "pr"]);
+const TRIAGE_CONCURRENCY_KEYS = new Set(["runs"]);
+const TRIAGE_KIND_KEYS = new Set(["bug", "feature"]);
+const TRIAGE_KIND_RULE_KEYS = new Set(["label", "type"]);
+const TRIAGE_SAFETY_KEYS = new Set([
+    "allowAuthors",
+    "allowMentionActors",
+    "allowMentionRoles",
+    "blockedLabels",
+    "requiredLabels",
+]);
 const SAFETY_KEYS = new Set([
     "allowAuthors",
     "blockedPaths",
@@ -88,6 +127,19 @@ const MERGE_PROMPT_KEYS = new Set([
     "edit",
     "editGuidelines",
 ]);
+const TRIAGE_PROMPT_KEYS = new Set([
+    "action",
+    "bug",
+    "comment",
+    "commentClassification",
+    "createPr",
+    "duplicate",
+    "existingPr",
+    "feature",
+    "kind",
+    "question",
+    "reconsider",
+]);
 function githubHost(config) {
     return config.github?.host ?? "github.com";
 }
@@ -227,6 +279,41 @@ function validateReviewerList(reviewers, path, errors, catalog) {
         }
     });
 }
+function validateTriageAgentList(agents, path, errors, catalog) {
+    if (agents == null)
+        return;
+    if (!Array.isArray(agents)) {
+        errors.push(`${path} must be an array`);
+        return;
+    }
+    if (agents.length < 3)
+        errors.push(`${path} must contain at least 3 agents`);
+    if (agents.length % 2 === 0)
+        errors.push(`${path} must contain an odd number of agents`);
+    agents.forEach((agent, index) => {
+        if (!agent || typeof agent !== "object") {
+            errors.push(`${path}[${index}] must be an object`);
+            return;
+        }
+        validateKnownKeys(agent, `${path}[${index}]`, TRIAGE_AGENT_KEYS, errors);
+        if (!agent.model)
+            errors.push(`${path}[${index}].model is required`);
+        validateString(agent.model, `${path}[${index}].model`, errors);
+        validateModel(agent.model, `${path}[${index}].model`, errors, catalog);
+        validateString(agent.persona, `${path}[${index}].persona`, errors);
+        if (agent.options != null && !isPlainObject(agent.options))
+            errors.push(`${path}[${index}].options must be an object`);
+        validatePermissionConfig(agent.permissions, `${path}[${index}].permissions`, errors);
+        if (agent.id) {
+            if (!validateReviewerId(agent.id)) {
+                errors.push(`${path}[${index}].id may contain only letters, numbers, underscores, and hyphens`);
+            }
+            if (RESERVED_REVIEWER_KEYS.has(agent.id)) {
+                errors.push(`${path}[${index}].id is reserved: ${agent.id}`);
+            }
+        }
+    });
+}
 function validateResolvedReviewers(reviewers, path, errors) {
     const keys = new Set();
     const accounts = new Set();
@@ -239,6 +326,14 @@ function validateResolvedReviewers(reviewers, path, errors) {
         accounts.add(reviewer.account);
     }
 }
+function validateResolvedAgentKeys(agents, path, errors) {
+    const keys = 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);
+    }
+}
 function validateEditor(editor, path, errors, catalog) {
     if (!editor)
         return;
@@ -282,6 +377,40 @@ function validateEditor(editor, path, errors, catalog) {
         }
     }
 }
+function validateTriageCreator(creator, path, errors, catalog) {
+    if (!creator)
+        return;
+    if (!isPlainObject(creator)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    validateKnownKeys(creator, path, TRIAGE_CREATOR_KEYS, errors);
+    if (!creator.model)
+        errors.push(`${path}.model is required`);
+    validateString(creator.account, `${path}.account`, errors);
+    validateString(creator.model, `${path}.model`, errors);
+    validateString(creator.persona, `${path}.persona`, errors);
+    validateModel(creator.model, `${path}.model`, errors, catalog);
+    if (creator.options != null && !isPlainObject(creator.options)) {
+        errors.push(`${path}.options must be an object`);
+    }
+    validatePermissionConfig(creator.permissions, `${path}.permissions`, errors);
+    const author = creator.author;
+    if (!author || !isPlainObject(author)) {
+        if (author != null)
+            errors.push(`${path}.author must be an object`);
+        errors.push(`${path}.author.name is required`);
+        errors.push(`${path}.author.email is required`);
+        return;
+    }
+    validateKnownKeys(author, `${path}.author`, AUTHOR_KEYS, errors);
+    if (!author.name)
+        errors.push(`${path}.author.name is required`);
+    validateString(author.name, `${path}.author.name`, errors);
+    if (!author.email)
+        errors.push(`${path}.author.email is required`);
+    validateString(author.email, `${path}.author.email`, errors);
+}
 function validateMerge(config, errors, options) {
     const merge = config.merge;
     if (options.requireGithub ?? true) {
@@ -407,6 +536,17 @@ function validateStringArray(value, path, errors) {
             errors.push(`${path}[${index}] must be a string`);
     });
 }
+function validateStringArrayObject(value, path, keys, errors) {
+    if (value == null)
+        return;
+    if (!isPlainObject(value)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    validateKnownKeys(value, path, keys, errors);
+    for (const key of keys)
+        validateStringArray(value[key], `${path}.${key}`, errors);
+}
 function validateSafety(config, errors) {
     const safety = config.review?.safety;
     if (safety != null && !isPlainObject(safety)) {
@@ -436,12 +576,65 @@ function validatePromptObject(prompts, path, keys, errors) {
             errors.push(`${path}.${key} must be a string`);
     }
 }
+function validateTriage(config, errors, options) {
+    const triage = config.triage;
+    if (!triage)
+        return;
+    if (!isPlainObject(triage)) {
+        errors.push("triage must be an object");
+        return;
+    }
+    validateKnownKeys(triage, "triage", TRIAGE_KEYS, errors);
+    const automation = triage.automation;
+    const concurrency = triage.concurrency;
+    const kind = triage.kind;
+    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);
+    }
+    validateTriageCreator(triage.creator, "triage.creator", errors, options.modelCatalog);
+    if (automation?.pr && !triage.creator)
+        errors.push("triage.creator is required when triage.automation.pr is true");
+    if (automation != null && !isPlainObject(automation)) {
+        errors.push("triage.automation must be an object");
+    }
+    validateKnownKeys(automation, "triage.automation", TRIAGE_AUTOMATION_KEYS, errors);
+    validateBoolean(automation?.close, "triage.automation.close", errors);
+    validateBoolean(automation?.pr, "triage.automation.pr", errors);
+    validateStringArray(automation?.clear, "triage.automation.clear", errors);
+    validateKnownKeys(concurrency, "triage.concurrency", TRIAGE_CONCURRENCY_KEYS, errors);
+    if (concurrency?.runs != null &&
+        (typeof concurrency.runs !== "number" ||
+            !Number.isInteger(concurrency.runs) ||
+            concurrency.runs < 1)) {
+        errors.push("triage.concurrency.runs must be a positive integer");
+    }
+    validateKnownKeys(kind, "triage.kind", TRIAGE_KIND_KEYS, errors);
+    validateStringArrayObject(kind?.bug, "triage.kind.bug", TRIAGE_KIND_RULE_KEYS, errors);
+    validateStringArrayObject(kind?.feature, "triage.kind.feature", TRIAGE_KIND_RULE_KEYS, errors);
+    validateKnownKeys(safety, "triage.safety", TRIAGE_SAFETY_KEYS, errors);
+    validateStringArray(safety?.allowAuthors, "triage.safety.allowAuthors", errors);
+    validateStringArray(safety?.allowMentionActors, "triage.safety.allowMentionActors", errors);
+    validateStringArray(safety?.allowMentionRoles, "triage.safety.allowMentionRoles", errors);
+    validateStringArray(safety?.blockedLabels, "triage.safety.blockedLabels", errors);
+    validateStringArray(safety?.requiredLabels, "triage.safety.requiredLabels", errors);
+    validateString(triage.output, "triage.output", errors);
+    validateString(triage.worktree, "triage.worktree", errors);
+}
 async function validatePrompts(config, errors, directory) {
     validatePromptObject(config.review?.prompts, "review.prompts", REVIEW_PROMPT_KEYS, errors);
     validatePromptObject(config.merge?.prompts, "merge.prompts", MERGE_PROMPT_KEYS, errors);
+    validatePromptObject(config.triage?.prompts, "triage.prompts", TRIAGE_PROMPT_KEYS, errors);
     const promptEntries = [
         ...Object.entries(config.review?.prompts ?? {}).map(([key, value]) => [`review.prompts.${key}`, value]),
         ...Object.entries(config.merge?.prompts ?? {}).map(([key, value]) => [`merge.prompts.${key}`, value]),
+        ...Object.entries(config.triage?.prompts ?? {}).map(([key, value]) => [`triage.prompts.${key}`, value]),
     ];
     await Promise.all(promptEntries.map(async ([path, value]) => {
         if (typeof value !== "string")
@@ -464,6 +657,10 @@ async function validateAuth(config, exec, errors) {
         accounts.add(reviewer.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) => {
         try {
             await exec(`gh auth token${ghHostOption(config)} --user ${JSON.stringify(account)}`);
@@ -493,6 +690,29 @@ 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) {
+        try {
+            const permissions = await fetchPermissions(config, exec, config.triage.account);
+            if (!permissions.pull) {
+                errors.push(`GitHub account cannot read repository for issue triage: ${config.triage.account}`);
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not validate repository permissions for GitHub account: ${config.triage.account} (${error.message})`);
+        }
+    }
+    if (agents.triageCreator?.account &&
+        agents.triageCreator.account !== config.triage?.account) {
+        try {
+            const permissions = await fetchPermissions(config, exec, agents.triageCreator.account);
+            if (!permissions.push) {
+                errors.push(`GitHub account cannot push to repository for triage PR creation: ${agents.triageCreator.account}`);
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not validate repository permissions for GitHub account: ${agents.triageCreator.account} (${error.message})`);
+        }
+    }
     if (!agents.editor)
         return;
     try {
@@ -522,10 +742,10 @@ export async function validateConfig(config, options = {}) {
         validateKnownKeys(config.agents, "agents", AGENTS_KEYS, errors);
         validatePermissionConfig(config.agents?.permissions, "agents.permissions", errors);
     }
-    if (!config.review) {
+    if ((options.requireReview ?? true) && !config.review) {
         errors.push("review is required");
     }
-    else {
+    else if (config.review) {
         if (!isPlainObject(config.review)) {
             errors.push("review must be an object");
         }
@@ -539,6 +759,9 @@ export async function validateConfig(config, options = {}) {
             validateResolvedReviewers(resolveAgents(config).reviewers, "review.resolvedAgents", errors);
         }
     }
+    if (options.requireTriage && !config.triage) {
+        errors.push("triage is required");
+    }
     validateMerge(config, errors, options);
     validateReviewMerge(config, errors);
     validateAutomation(config, errors);
@@ -546,6 +769,7 @@ export async function validateConfig(config, options = {}) {
     validateChecks(config, errors);
     validateConcurrency(config, errors);
     validateSafety(config, errors);
+    validateTriage(config, errors, options);
     await validatePrompts(config, errors, options.directory);
     if (config.output != null && !isPlainObject(config.output)) {
         errors.push("output must be an object");

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

@@ -97,6 +97,94 @@ 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`);
     return JSON.parse(json);
 }
+export async function fetchIssue(exec, repository, issue) {
+    const raw = await exec(`gh issue view ${issue} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,body,url,state,author,labels,type`);
+    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,
+        type: data.type?.name,
+        url: data.url,
+    };
+}
+export async function fetchIssueComments(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) { 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);
+    return (data.data?.repository?.issue?.comments?.nodes?.map((comment) => ({
+        author: comment.author?.login ?? "",
+        authorAssociation: comment.authorAssociation,
+        body: comment.body ?? "",
+        createdAt: comment.createdAt,
+        id: comment.databaseId,
+        url: comment.url,
+    })) ?? []);
+}
+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"
+            : source.state === "CLOSED"
+                ? "CLOSED"
+                : "OPEN";
+        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,
+        });
+    }
+    return [...prs.values()];
+}
+export async function searchDuplicateIssues(exec, repository, issue, limit = 5) {
+    const query = `${issue.title} repo:${repoSlug(repository)} is:issue -${issue.number}`;
+    const raw = await exec(`gh search issues ${shellQuote(query)} --json number,title,url,state,body --limit ${limit}`);
+    const data = JSON.parse(raw);
+    return data
+        .filter((item) => item.number !== issue.number)
+        .map((item) => ({
+        ...item,
+        whyCandidate: "GitHub issue search matched the title.",
+    }));
+}
+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 {
+        return await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/issues/${issue}/comments --method POST --input ${shellQuote(payloadPath)} --jq .html_url`, ghTokenEnv(token));
+    }
+    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 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}`);
@@ -366,6 +454,11 @@ export async function pushHead(exec, repository, worktreePath, account, head) {
         },
     });
 }
+export async function createPullRequest(exec, repository, account, input) {
+    const token = await ghToken(exec, repository, account);
+    const baseFlag = input.base ? ` --base ${shellQuote(input.base)}` : "";
+    return exec(`gh pr create --repo ${shellQuote(repoSpecifier(repository))} --head ${shellQuote(input.head)}${baseFlag} --title ${shellQuote(input.title)} --body ${shellQuote(input.body)}`, ghTokenEnv(token));
+}
 export async function configureGitIdentity(exec, worktreePath, identity) {
     if (identity.name) {
         await exec(`git config --worktree user.name ${shellQuote(identity.name)}`, {