@sentry/junior-github 0.129.0 → 0.130.0

package/dist/index.js

@@ -5,12 +5,15 @@ import {
   GITHUB_ISSUE_SUGGESTED_EVENTS,
   GITHUB_PULL_REQUEST_EVENTS,
   GITHUB_PULL_REQUEST_SUGGESTED_EVENTS,
+  GITHUB_RELEASE_EVENTS,
+  GITHUB_RELEASE_SUGGESTED_EVENTS,
   gitHubDeploymentSourceSubscribable,
   gitHubIssueSubscribable,
   gitHubPullRequestSubscribable,
+  gitHubReleaseSourceSubscribable,
   gitHubRepositorySubscribable,
   normalizeGitHubResourceEvents
-} from "./chunk-25NTEYYB.js";
+} from "./chunk-6XR7J3LQ.js";
 
 // src/plugin.ts
 import {
@@ -1207,7 +1210,7 @@ function createGitHubGetPullRequestTool(ctx) {
   });
 }
 
-// src/tools/get-repository.ts
+// src/tools/get-release.ts
 import {
   definePluginTool as definePluginTool5,
   PluginToolInputError as PluginToolInputError6,
@@ -1216,26 +1219,49 @@ import {
 } from "@sentry/junior-plugin-api";
 import { z as z5 } from "zod";
 var inputSchema3 = z5.object({
-  repo: z5.string().describe('Repository in "owner/name" format.')
+  repo: z5.string().describe('Repository in "owner/name" format.'),
+  tag: z5.string().trim().min(1).describe(
+    "Optional release tag name. Omit to inspect and watch every published release in the repository."
+  ).optional()
 }).strict();
-var repositorySchema = z5.object({
-  defaultBranch: z5.string(),
-  description: z5.string().nullable(),
-  fullName: z5.string(),
-  private: z5.boolean(),
+var releaseSchema = z5.object({
+  createdAt: z5.string(),
+  draft: z5.boolean(),
+  htmlUrl: z5.string(),
+  id: z5.number(),
+  name: z5.string().nullable(),
+  prerelease: z5.boolean(),
+  publishedAt: z5.string().nullable(),
+  tagName: z5.string(),
+  targetCommitish: z5.string()
+}).strict();
+var releaseSourceSchema = z5.object({
+  release: releaseSchema.nullable(),
+  repo: z5.string(),
   subscribable: subscribableResourceSchema5.optional(),
-  url: z5.string()
-});
+  tag: z5.string().nullable()
+}).strict();
 var outputSchema3 = pluginToolOutputSchema5.extend({
-  target: z5.literal("getRepository"),
-  ...repositorySchema.shape
-});
+  target: z5.literal("getRelease"),
+  ...releaseSourceSchema.shape
+}).strict();
+var providerReleaseSchema = z5.object({
+  created_at: z5.string(),
+  draft: z5.boolean(),
+  html_url: z5.string(),
+  id: z5.number(),
+  name: z5.string().nullable(),
+  prerelease: z5.boolean(),
+  published_at: z5.string().nullable(),
+  tag_name: z5.string(),
+  target_commitish: z5.string()
+}).passthrough();
 function parseRepo5(value) {
   const parts = value.split("/").map((part) => part.trim());
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
     throw new PluginToolInputError6('repo must use "owner/name" format');
   }
-  return { owner: parts[0], name: parts[1] };
+  return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
 }
 async function readJson3(response) {
   const text2 = await response.text();
@@ -1246,7 +1272,23 @@ async function readJson3(response) {
     return text2;
   }
 }
-function createGitHubGetRepositoryTool(ctx) {
+function repositoryUrl2(repo, path) {
+  return `https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}/${path}`;
+}
+function mapRelease(providerRelease) {
+  return {
+    createdAt: providerRelease.created_at,
+    draft: providerRelease.draft,
+    htmlUrl: providerRelease.html_url,
+    id: providerRelease.id,
+    name: providerRelease.name,
+    prerelease: providerRelease.prerelease,
+    publishedAt: providerRelease.published_at,
+    tagName: providerRelease.tag_name,
+    targetCommitish: providerRelease.target_commitish
+  };
+}
+function createGitHubGetReleaseTool(ctx) {
   return definePluginTool5({
     annotations: {
       destructiveHint: false,
@@ -1254,11 +1296,127 @@ function createGitHubGetRepositoryTool(ctx) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    description: "Get a GitHub repository. Use this when repository-wide issue activity may need resource-event monitoring; the result includes a subscribable hint when GitHub webhooks are configured.",
+    description: "Get a GitHub release for an exact repository, optionally limited to one tag. The result remains subscribable when no release exists yet, so use it before waiting for a published release. Omit the tag to watch every published release in the repository.",
     inputSchema: inputSchema3,
     outputSchema: outputSchema3,
     async execute(input) {
       const repo = parseRepo5(input.repo);
+      const tag = input.tag?.trim() || void 0;
+      let release = null;
+      if (tag) {
+        const response = await ctx.egress.fetch({
+          provider: "github",
+          operation: "github.release.get",
+          request: new Request(
+            repositoryUrl2(repo, `releases/tags/${encodeURIComponent(tag)}`),
+            {
+              headers: {
+                Accept: "application/vnd.github+json",
+                "X-GitHub-Api-Version": "2022-11-28"
+              }
+            }
+          )
+        });
+        const body = await readJson3(response);
+        if (response.ok) {
+          release = mapRelease(providerReleaseSchema.parse(body));
+        } else if (response.status !== 404) {
+          throw new Error(
+            `GitHub release lookup failed with HTTP ${response.status}`
+          );
+        }
+      } else {
+        const response = await ctx.egress.fetch({
+          provider: "github",
+          operation: "github.release.latest",
+          request: new Request(repositoryUrl2(repo, "releases/latest"), {
+            headers: {
+              Accept: "application/vnd.github+json",
+              "X-GitHub-Api-Version": "2022-11-28"
+            }
+          })
+        });
+        const body = await readJson3(response);
+        if (response.ok) {
+          release = mapRelease(providerReleaseSchema.parse(body));
+        } else if (response.status === 404) {
+          release = null;
+        } else {
+          throw new Error(
+            `GitHub release lookup failed with HTTP ${response.status}`
+          );
+        }
+      }
+      const subscribable = ctx.resourceEvents.canSubscribe ? gitHubReleaseSourceSubscribable({
+        repo: repo.ref,
+        tag
+      }) : void 0;
+      const data = {
+        release,
+        repo: repo.ref,
+        tag: tag ?? null,
+        ...subscribable ? { subscribable } : {}
+      };
+      return {
+        target: "getRelease",
+        ...data
+      };
+    }
+  });
+}
+
+// src/tools/get-repository.ts
+import {
+  definePluginTool as definePluginTool6,
+  PluginToolInputError as PluginToolInputError7,
+  pluginToolOutputSchema as pluginToolOutputSchema6,
+  subscribableResourceSchema as subscribableResourceSchema6
+} from "@sentry/junior-plugin-api";
+import { z as z6 } from "zod";
+var inputSchema4 = z6.object({
+  repo: z6.string().describe('Repository in "owner/name" format.')
+}).strict();
+var repositorySchema = z6.object({
+  defaultBranch: z6.string(),
+  description: z6.string().nullable(),
+  fullName: z6.string(),
+  private: z6.boolean(),
+  subscribable: subscribableResourceSchema6.optional(),
+  url: z6.string()
+});
+var outputSchema4 = pluginToolOutputSchema6.extend({
+  target: z6.literal("getRepository"),
+  ...repositorySchema.shape
+});
+function parseRepo6(value) {
+  const parts = value.split("/").map((part) => part.trim());
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new PluginToolInputError7('repo must use "owner/name" format');
+  }
+  return { owner: parts[0], name: parts[1] };
+}
+async function readJson4(response) {
+  const text2 = await response.text();
+  if (!text2) return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function createGitHubGetRepositoryTool(ctx) {
+  return definePluginTool6({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: true
+    },
+    description: "Get a GitHub repository. Use this when repository-wide issue activity may need resource-event monitoring; the result includes a subscribable hint when GitHub webhooks are configured.",
+    inputSchema: inputSchema4,
+    outputSchema: outputSchema4,
+    async execute(input) {
+      const repo = parseRepo6(input.repo);
       const response = await ctx.egress.fetch({
         provider: "github",
         operation: "github.repository.get",
@@ -1272,18 +1430,18 @@ function createGitHubGetRepositoryTool(ctx) {
           }
         )
       });
-      const parsed = await readJson3(response);
+      const parsed = await readJson4(response);
       if (!response.ok) {
-        throw new PluginToolInputError6(
+        throw new PluginToolInputError7(
           `GitHub repository lookup failed with HTTP ${response.status}`
         );
       }
-      const providerResult = z5.object({
-        default_branch: z5.string(),
-        description: z5.string().nullable(),
-        full_name: z5.string(),
-        html_url: z5.string(),
-        private: z5.boolean()
+      const providerResult = z6.object({
+        default_branch: z6.string(),
+        description: z6.string().nullable(),
+        full_name: z6.string(),
+        html_url: z6.string(),
+        private: z6.boolean()
       }).parse(parsed);
       const subscribable = ctx.resourceEvents.canSubscribe ? gitHubRepositorySubscribable({
         repo: providerResult.full_name
@@ -1306,53 +1464,53 @@ function createGitHubGetRepositoryTool(ctx) {
 
 // src/tools/update-pull-request.ts
 import {
-  definePluginTool as definePluginTool6,
-  PluginToolInputError as PluginToolInputError7,
-  pluginToolOutputSchema as pluginToolOutputSchema6
+  definePluginTool as definePluginTool7,
+  PluginToolInputError as PluginToolInputError8,
+  pluginToolOutputSchema as pluginToolOutputSchema7
 } from "@sentry/junior-plugin-api";
-import { z as z6 } from "zod";
-import { subscribableResourceSchema as subscribableResourceSchema6 } from "@sentry/junior-plugin-api";
-var inputSchema4 = z6.object({
-  repo: z6.string().describe('Repository in "owner/name" format.'),
-  number: z6.number().int().positive().describe("Pull request number."),
-  title: z6.string().trim().min(1).optional().describe("Replacement pull request title."),
-  body: z6.string().optional().describe(
+import { z as z7 } from "zod";
+import { subscribableResourceSchema as subscribableResourceSchema7 } from "@sentry/junior-plugin-api";
+var inputSchema5 = z7.object({
+  repo: z7.string().describe('Repository in "owner/name" format.'),
+  number: z7.number().int().positive().describe("Pull request number."),
+  title: z7.string().trim().min(1).optional().describe("Replacement pull request title."),
+  body: z7.string().optional().describe(
     "Replacement pull request body. Junior appends requester attribution and the conversation footer."
   ),
-  base: z6.string().trim().min(1).optional().describe("Replacement base branch."),
-  state: z6.enum(["open", "closed"]).optional().describe("Replacement pull request state.")
+  base: z7.string().trim().min(1).optional().describe("Replacement base branch."),
+  state: z7.enum(["open", "closed"]).optional().describe("Replacement pull request state.")
 }).strict().refine(
   ({ title, body, base, state }) => title !== void 0 || body !== void 0 || base !== void 0 || state !== void 0,
   { message: "At least one pull request field must be provided." }
 );
-var pullRequestSchema2 = z6.object({
-  base: z6.string(),
-  body: z6.string().nullable(),
-  draft: z6.boolean(),
-  number: z6.number(),
-  state: z6.string(),
-  subscribable: subscribableResourceSchema6.optional(),
-  title: z6.string(),
-  url: z6.string()
+var pullRequestSchema2 = z7.object({
+  base: z7.string(),
+  body: z7.string().nullable(),
+  draft: z7.boolean(),
+  number: z7.number(),
+  state: z7.string(),
+  subscribable: subscribableResourceSchema7.optional(),
+  title: z7.string(),
+  url: z7.string()
 });
-var outputSchema4 = pluginToolOutputSchema6.extend({
-  target: z6.literal("updatePullRequest"),
+var outputSchema5 = pluginToolOutputSchema7.extend({
+  target: z7.literal("updatePullRequest"),
   ...pullRequestSchema2.shape
 });
 function nonEmptyString4(value, name) {
   if (!value?.trim()) {
-    throw new PluginToolInputError7(`${name} is required`);
+    throw new PluginToolInputError8(`${name} is required`);
   }
   return value.trim();
 }
-function parseRepo6(value) {
+function parseRepo7(value) {
   const parts = value.split("/").map((part) => part.trim());
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new PluginToolInputError7('repo must use "owner/name" format');
+    throw new PluginToolInputError8('repo must use "owner/name" format');
   }
   return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
 }
-async function readJson4(response) {
+async function readJson5(response) {
   const text2 = await response.text();
   if (!text2) return void 0;
   try {
@@ -1370,7 +1528,7 @@ function githubApiErrorMessage3(payload) {
   return "GitHub request failed";
 }
 function createGitHubUpdatePullRequestTool(ctx) {
-  return definePluginTool6({
+  return definePluginTool7({
     annotations: {
       destructiveHint: true,
       idempotentHint: true,
@@ -1378,18 +1536,18 @@ function createGitHubUpdatePullRequestTool(ctx) {
       readOnlyHint: false
     },
     description: "Update an existing GitHub pull request's title, body, base branch, or open/closed state. Use this instead of raw GitHub API calls when changing PR metadata.",
-    inputSchema: inputSchema4,
-    outputSchema: outputSchema4,
+    inputSchema: inputSchema5,
+    outputSchema: outputSchema5,
     async execute(input) {
-      const parsedInput = inputSchema4.safeParse(input);
+      const parsedInput = inputSchema5.safeParse(input);
       if (!parsedInput.success) {
-        throw new PluginToolInputError7(
+        throw new PluginToolInputError8(
           "Invalid GitHub updatePullRequest input.",
           { cause: parsedInput.error }
         );
       }
       const update = parsedInput.data;
-      const repo = parseRepo6(update.repo);
+      const repo = parseRepo7(update.repo);
       const payload = {
         ...update.title !== void 0 ? { title: update.title } : {},
         ...update.body !== void 0 ? {
@@ -1418,20 +1576,20 @@ function createGitHubUpdatePullRequestTool(ctx) {
           }
         )
       });
-      const parsed = await readJson4(response);
+      const parsed = await readJson5(response);
       if (!response.ok) {
         throw new Error(
           `GitHub pull request update failed with HTTP ${response.status}: ${githubApiErrorMessage3(parsed)}`
         );
       }
-      const providerResult = z6.object({
-        base: z6.object({ ref: z6.string() }),
-        body: z6.string().nullable().optional().default(null),
-        draft: z6.boolean(),
-        html_url: z6.string(),
-        number: z6.number(),
-        state: z6.string(),
-        title: z6.string()
+      const providerResult = z7.object({
+        base: z7.object({ ref: z7.string() }),
+        body: z7.string().nullable().optional().default(null),
+        draft: z7.boolean(),
+        html_url: z7.string(),
+        number: z7.number(),
+        state: z7.string(),
+        title: z7.string()
       }).parse(parsed);
       const subscribable = ctx.resourceEvents.canSubscribe ? gitHubPullRequestSubscribable({
         number: providerResult.number,
@@ -1462,6 +1620,7 @@ function createGitHubTools(ctx) {
     createPullRequest: createGitHubPullRequestTool(ctx),
     getDeployment: createGitHubGetDeploymentTool(ctx),
     getPullRequest: createGitHubGetPullRequestTool(ctx),
+    getRelease: createGitHubGetReleaseTool(ctx),
     getRepository: createGitHubGetRepositoryTool(ctx),
     updatePullRequest: createGitHubUpdatePullRequestTool(ctx)
   };
@@ -1472,7 +1631,7 @@ import { createHmac, timingSafeEqual } from "crypto";
 
 // src/issue-outcomes/store.ts
 import { and, eq, lte, sql as sql2 } from "drizzle-orm";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/db/schema.ts
 import { sql } from "drizzle-orm";
@@ -1484,18 +1643,18 @@ import {
   text,
   timestamp
 } from "drizzle-orm/pg-core";
-import { z as z7 } from "zod";
-var githubPullRequestStateSchema = z7.enum([
+import { z as z8 } from "zod";
+var githubPullRequestStateSchema = z8.enum([
   "closed_unmerged",
   "merged",
   "open"
 ]);
-var githubPullRequestCommitCompositionSchema = z7.enum([
+var githubPullRequestCommitCompositionSchema = z8.enum([
   "junior_only",
   "mixed"
 ]);
-var githubIssueStateSchema = z7.enum(["closed", "open"]);
-var githubIssueStateReasonSchema = z7.enum([
+var githubIssueStateSchema = z8.enum(["closed", "open"]);
+var githubIssueStateReasonSchema = z8.enum([
   "completed",
   "duplicate",
   "not_planned",
@@ -1564,21 +1723,21 @@ var juniorGitHubPullRequestIssues = pgTable(
 );
 
 // src/issue-outcomes/store.ts
-var githubIssueOutcomeInputSchema = z8.object({
-  candidateOwned: z8.boolean(),
-  closedAt: z8.date().optional(),
-  issueId: z8.string().min(1),
-  number: z8.number().int().positive(),
-  openedAt: z8.date(),
-  repositoryFullName: z8.string().min(1),
-  repositoryId: z8.string().min(1),
+var githubIssueOutcomeInputSchema = z9.object({
+  candidateOwned: z9.boolean(),
+  closedAt: z9.date().optional(),
+  issueId: z9.string().min(1),
+  number: z9.number().int().positive(),
+  openedAt: z9.date(),
+  repositoryFullName: z9.string().min(1),
+  repositoryId: z9.string().min(1),
   state: githubIssueStateSchema,
   stateReason: githubIssueStateReasonSchema.optional(),
-  updatedAt: z8.date()
+  updatedAt: z9.date()
 }).strict();
-var githubIssueConversationsInputSchema = z8.object({
-  conversationIds: z8.array(z8.string().min(1)).min(1),
-  issueId: z8.string().min(1)
+var githubIssueConversationsInputSchema = z9.object({
+  conversationIds: z9.array(z9.string().min(1)).min(1),
+  issueId: z9.string().min(1)
 }).strict();
 function projectionValues(input) {
   return {
@@ -1631,32 +1790,32 @@ async function recordGitHubIssueConversations(db, input) {
 
 // src/pull-request-outcomes/store.ts
 import { and as and2, eq as eq2, lte as lte2, sql as sql3 } from "drizzle-orm";
-import { z as z9 } from "zod";
-var githubPullRequestOutcomeInputSchema = z9.object({
-  candidateOwned: z9.boolean(),
-  closedAt: z9.date().optional(),
+import { z as z10 } from "zod";
+var githubPullRequestOutcomeInputSchema = z10.object({
+  candidateOwned: z10.boolean(),
+  closedAt: z10.date().optional(),
   commitComposition: githubPullRequestCommitCompositionSchema.optional(),
-  mergedAt: z9.date().optional(),
-  number: z9.number().int().positive(),
-  openedAt: z9.date(),
-  pullRequestId: z9.string().min(1),
-  repositoryFullName: z9.string().min(1),
-  repositoryId: z9.string().min(1),
+  mergedAt: z10.date().optional(),
+  number: z10.number().int().positive(),
+  openedAt: z10.date(),
+  pullRequestId: z10.string().min(1),
+  repositoryFullName: z10.string().min(1),
+  repositoryId: z10.string().min(1),
   state: githubPullRequestStateSchema,
-  updatedAt: z9.date()
+  updatedAt: z10.date()
 }).strict();
-var githubPullRequestConversationsInputSchema = z9.object({
-  conversationIds: z9.array(z9.string().min(1)).min(1),
-  pullRequestId: z9.string().min(1)
+var githubPullRequestConversationsInputSchema = z10.object({
+  conversationIds: z10.array(z10.string().min(1)).min(1),
+  pullRequestId: z10.string().min(1)
 }).strict();
-var githubPullRequestLinkedIssuesInputSchema = z9.object({
-  linkedIssues: z9.array(
-    z9.object({
-      number: z9.number().int().positive(),
-      repositoryFullName: z9.string().min(1)
+var githubPullRequestLinkedIssuesInputSchema = z10.object({
+  linkedIssues: z10.array(
+    z10.object({
+      number: z10.number().int().positive(),
+      repositoryFullName: z10.string().min(1)
     }).strict()
   ).min(1),
-  pullRequestId: z9.string().min(1)
+  pullRequestId: z10.string().min(1)
 }).strict();
 function projectionValues2(input) {
   return {
@@ -1746,7 +1905,7 @@ async function recordGitHubPullRequestLinkedIssues(db, input) {
 }
 
 // src/webhooks/issue-outcome.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/webhooks/ownership.ts
 var GITHUB_NOREPLY_DOMAIN = "users.noreply.github.com";
@@ -1763,38 +1922,38 @@ function botLoginFromEmail(value) {
 }
 
 // src/webhooks/issue-outcome.ts
-var canonicalIssueOutcomeSchema = z10.object({
-  action: z10.enum(["opened", "closed", "reopened"]),
-  issue: z10.object({
-    body: z10.string().nullable().optional(),
-    closed_at: z10.string().nullable().optional(),
-    created_at: z10.string(),
-    id: z10.number().int().positive(),
-    number: z10.number().int().positive(),
+var canonicalIssueOutcomeSchema = z11.object({
+  action: z11.enum(["opened", "closed", "reopened"]),
+  issue: z11.object({
+    body: z11.string().nullable().optional(),
+    closed_at: z11.string().nullable().optional(),
+    created_at: z11.string(),
+    id: z11.number().int().positive(),
+    number: z11.number().int().positive(),
     state_reason: githubIssueStateReasonSchema.nullable().optional(),
-    updated_at: z10.string(),
-    user: z10.object({ login: z10.string().min(1) }).strict()
+    updated_at: z11.string(),
+    user: z11.object({ login: z11.string().min(1) }).strict()
   }).strict(),
-  repository: z10.object({
-    full_name: z10.string().min(1),
-    id: z10.number().int().positive()
+  repository: z11.object({
+    full_name: z11.string().min(1),
+    id: z11.number().int().positive()
   }).strict()
 }).strict();
-var issueOutcomeSchema = z10.object({
-  action: z10.enum(["opened", "closed", "reopened"]),
-  issue: z10.object({
-    body: z10.string().nullable().optional(),
-    closed_at: z10.string().nullable().optional(),
-    created_at: z10.string(),
-    id: z10.number().int().positive(),
-    number: z10.number().int().positive(),
+var issueOutcomeSchema = z11.object({
+  action: z11.enum(["opened", "closed", "reopened"]),
+  issue: z11.object({
+    body: z11.string().nullable().optional(),
+    closed_at: z11.string().nullable().optional(),
+    created_at: z11.string(),
+    id: z11.number().int().positive(),
+    number: z11.number().int().positive(),
     state_reason: githubIssueStateReasonSchema.nullable().optional(),
-    updated_at: z10.string(),
-    user: z10.object({ login: z10.string().min(1) }).passthrough()
+    updated_at: z11.string(),
+    user: z11.object({ login: z11.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z10.object({
-    full_name: z10.string().min(1),
-    id: z10.number().int().positive()
+  repository: z11.object({
+    full_name: z11.string().min(1),
+    id: z11.number().int().positive()
   }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalIssueOutcomeSchema.parse({
@@ -1815,7 +1974,7 @@ var issueOutcomeSchema = z10.object({
     }
   })
 );
-var issueLifecycleActionSchema = z10.object({ action: z10.string() }).passthrough();
+var issueLifecycleActionSchema = z11.object({ action: z11.string() }).passthrough();
 function timestamp2(value) {
   if (!value) return void 0;
   const parsed = new Date(value);
@@ -1861,21 +2020,21 @@ function normalizeGitHubIssueOutcome(args) {
     updatedAt
   };
 }
-var canonicalIssueConversationSchema = z10.object({
-  issue: z10.object({
-    body: z10.string().nullable().optional(),
-    id: z10.number().int().positive(),
-    user: z10.object({ login: z10.string().min(1) }).strict()
+var canonicalIssueConversationSchema = z11.object({
+  issue: z11.object({
+    body: z11.string().nullable().optional(),
+    id: z11.number().int().positive(),
+    user: z11.object({ login: z11.string().min(1) }).strict()
   }).strict(),
-  sender: z10.object({ login: z10.string().min(1) }).strict().optional()
+  sender: z11.object({ login: z11.string().min(1) }).strict().optional()
 }).strict();
-var issueConversationSchema = z10.object({
-  issue: z10.object({
-    body: z10.string().nullable().optional(),
-    id: z10.number().int().positive(),
-    user: z10.object({ login: z10.string().min(1) }).passthrough()
+var issueConversationSchema = z11.object({
+  issue: z11.object({
+    body: z11.string().nullable().optional(),
+    id: z11.number().int().positive(),
+    user: z11.object({ login: z11.string().min(1) }).passthrough()
   }).passthrough(),
-  sender: z10.object({ login: z10.string().min(1) }).passthrough().optional()
+  sender: z11.object({ login: z11.string().min(1) }).passthrough().optional()
 }).passthrough().transform(
   (provider) => canonicalIssueConversationSchema.parse({
     issue: {
@@ -1902,41 +2061,41 @@ function normalizeGitHubIssueConversations(args) {
 }
 
 // src/webhooks/pull-request-outcome.ts
-import { z as z11 } from "zod";
-var canonicalPullRequestOutcomeSchema = z11.object({
-  action: z11.enum(["opened", "closed", "reopened"]),
-  pull_request: z11.object({
-    body: z11.string().nullable().optional(),
-    closed_at: z11.string().nullable().optional(),
-    created_at: z11.string(),
-    id: z11.number().int().positive(),
-    merged: z11.boolean(),
-    merged_at: z11.string().nullable().optional(),
-    number: z11.number().int().positive(),
-    updated_at: z11.string(),
-    user: z11.object({ login: z11.string().min(1) }).strict()
+import { z as z12 } from "zod";
+var canonicalPullRequestOutcomeSchema = z12.object({
+  action: z12.enum(["opened", "closed", "reopened"]),
+  pull_request: z12.object({
+    body: z12.string().nullable().optional(),
+    closed_at: z12.string().nullable().optional(),
+    created_at: z12.string(),
+    id: z12.number().int().positive(),
+    merged: z12.boolean(),
+    merged_at: z12.string().nullable().optional(),
+    number: z12.number().int().positive(),
+    updated_at: z12.string(),
+    user: z12.object({ login: z12.string().min(1) }).strict()
   }).strict(),
-  repository: z11.object({
-    full_name: z11.string().min(1),
-    id: z11.number().int().positive()
+  repository: z12.object({
+    full_name: z12.string().min(1),
+    id: z12.number().int().positive()
   }).strict()
 }).strict();
-var pullRequestOutcomeSchema = z11.object({
-  action: z11.enum(["opened", "closed", "reopened"]),
-  pull_request: z11.object({
-    body: z11.string().nullable().optional(),
-    closed_at: z11.string().nullable().optional(),
-    created_at: z11.string(),
-    id: z11.number().int().positive(),
-    merged: z11.boolean(),
-    merged_at: z11.string().nullable().optional(),
-    number: z11.number().int().positive(),
-    updated_at: z11.string(),
-    user: z11.object({ login: z11.string().min(1) }).passthrough()
+var pullRequestOutcomeSchema = z12.object({
+  action: z12.enum(["opened", "closed", "reopened"]),
+  pull_request: z12.object({
+    body: z12.string().nullable().optional(),
+    closed_at: z12.string().nullable().optional(),
+    created_at: z12.string(),
+    id: z12.number().int().positive(),
+    merged: z12.boolean(),
+    merged_at: z12.string().nullable().optional(),
+    number: z12.number().int().positive(),
+    updated_at: z12.string(),
+    user: z12.object({ login: z12.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z11.object({
-    full_name: z11.string().min(1),
-    id: z11.number().int().positive()
+  repository: z12.object({
+    full_name: z12.string().min(1),
+    id: z12.number().int().positive()
   }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalPullRequestOutcomeSchema.parse({
@@ -1958,24 +2117,24 @@ var pullRequestOutcomeSchema = z11.object({
     }
   })
 );
-var pullRequestLifecycleActionSchema = z11.object({ action: z11.string() }).passthrough();
-var canonicalPullRequestConversationSchema = z11.object({
-  pull_request: z11.object({
-    body: z11.string().nullable().optional(),
-    id: z11.number().int().positive(),
-    user: z11.object({ login: z11.string().min(1) }).strict()
+var pullRequestLifecycleActionSchema = z12.object({ action: z12.string() }).passthrough();
+var canonicalPullRequestConversationSchema = z12.object({
+  pull_request: z12.object({
+    body: z12.string().nullable().optional(),
+    id: z12.number().int().positive(),
+    user: z12.object({ login: z12.string().min(1) }).strict()
   }).strict(),
-  repository: z11.object({ full_name: z11.string().min(1) }).strict(),
-  sender: z11.object({ login: z11.string().min(1) }).strict()
+  repository: z12.object({ full_name: z12.string().min(1) }).strict(),
+  sender: z12.object({ login: z12.string().min(1) }).strict()
 }).strict();
-var pullRequestConversationSchema = z11.object({
-  pull_request: z11.object({
-    body: z11.string().nullable().optional(),
-    id: z11.number().int().positive(),
-    user: z11.object({ login: z11.string().min(1) }).passthrough()
+var pullRequestConversationSchema = z12.object({
+  pull_request: z12.object({
+    body: z12.string().nullable().optional(),
+    id: z12.number().int().positive(),
+    user: z12.object({ login: z12.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z11.object({ full_name: z11.string().min(1) }).passthrough(),
-  sender: z11.object({ login: z11.string().min(1) }).passthrough()
+  repository: z12.object({ full_name: z12.string().min(1) }).passthrough(),
+  sender: z12.object({ login: z12.string().min(1) }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalPullRequestConversationSchema.parse({
     pull_request: {
@@ -2183,18 +2342,18 @@ function createGitHubWebhookRoute(args) {
 
 // src/outcomes/report.ts
 import { sql as sql5 } from "drizzle-orm";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/outcomes/cost.ts
 import { sql as sql4 } from "drizzle-orm";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var DAY_MS = 24 * 60 * 60 * 1e3;
-var costWindowSchema = z12.object({
-  days: z12.number().int().positive(),
-  issueCostUsd: z12.number().nonnegative().nullable(),
-  medianIssueCostUsd: z12.number().nonnegative().nullable(),
-  medianPullRequestCostUsd: z12.number().nonnegative().nullable(),
-  pullRequestCostUsd: z12.number().nonnegative().nullable()
+var costWindowSchema = z13.object({
+  days: z13.number().int().positive(),
+  issueCostUsd: z13.number().nonnegative().nullable(),
+  medianIssueCostUsd: z13.number().nonnegative().nullable(),
+  medianPullRequestCostUsd: z13.number().nonnegative().nullable(),
+  pullRequestCostUsd: z13.number().nonnegative().nullable()
 }).strict().transform((row) => ({
   days: row.days,
   issueCostUsd: row.issueCostUsd ?? void 0,
@@ -2202,12 +2361,12 @@ var costWindowSchema = z12.object({
   medianPullRequestCostUsd: row.medianPullRequestCostUsd ?? void 0,
   pullRequestCostUsd: row.pullRequestCostUsd ?? void 0
 }));
-var repositoryCostSchema = z12.object({
-  issueCostUsd: z12.number().nonnegative().nullable(),
-  medianIssueCostUsd: z12.number().nonnegative().nullable(),
-  medianPullRequestCostUsd: z12.number().nonnegative().nullable(),
-  pullRequestCostUsd: z12.number().nonnegative().nullable(),
-  repository: z12.string().min(1)
+var repositoryCostSchema = z13.object({
+  issueCostUsd: z13.number().nonnegative().nullable(),
+  medianIssueCostUsd: z13.number().nonnegative().nullable(),
+  medianPullRequestCostUsd: z13.number().nonnegative().nullable(),
+  pullRequestCostUsd: z13.number().nonnegative().nullable(),
+  repository: z13.string().min(1)
 }).strict().transform((row) => ({
   issueCostUsd: row.issueCostUsd ?? void 0,
   medianIssueCostUsd: row.medianIssueCostUsd ?? void 0,
@@ -2412,7 +2571,7 @@ async function aggregateGitHubCostWindows(args) {
     INNER JOIN issue_window ON issue_window.days = pull_request_window.days
     ORDER BY pull_request_window.days
   `);
-  return z12.array(costWindowSchema).parse(queryRows(result));
+  return z13.array(costWindowSchema).parse(queryRows(result));
 }
 async function aggregateGitHubRepositoryCosts(args) {
   if (!await hasConversationUsageTable(args.db)) {
@@ -2510,7 +2669,7 @@ async function aggregateGitHubRepositoryCosts(args) {
       ON issue_totals.repository = repositories.repository
     ORDER BY "repository" ASC
   `);
-  return z12.array(repositoryCostSchema).parse(queryRows(result));
+  return z13.array(repositoryCostSchema).parse(queryRows(result));
 }
 function formatCostUsd(value) {
   if (value === void 0) return "\u2014";
@@ -2525,12 +2684,12 @@ function formatCostUsd(value) {
 // src/outcomes/report.ts
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 var WINDOWS = [7, 30, 90];
-var pullRequestStatsSchema = z13.object({
-  closed: z13.number().int().nonnegative(),
-  created: z13.number().int().nonnegative(),
-  days: z13.number().int().positive(),
-  medianMergeTimeMs: z13.number().nonnegative().nullable(),
-  merged: z13.number().int().nonnegative()
+var pullRequestStatsSchema = z14.object({
+  closed: z14.number().int().nonnegative(),
+  created: z14.number().int().nonnegative(),
+  days: z14.number().int().positive(),
+  medianMergeTimeMs: z14.number().nonnegative().nullable(),
+  merged: z14.number().int().nonnegative()
 }).strict().transform((row) => {
   const terminal = row.merged + row.closed;
   return {
@@ -2539,12 +2698,12 @@ var pullRequestStatsSchema = z13.object({
     mergeRate: terminal > 0 ? row.merged / terminal : void 0
   };
 });
-var pullRequestRepositoryStatsSchema = z13.object({
-  closed: z13.number().int().nonnegative(),
-  created: z13.number().int().nonnegative(),
-  juniorOnly: z13.number().int().nonnegative(),
-  merged: z13.number().int().nonnegative(),
-  repository: z13.string().min(1)
+var pullRequestRepositoryStatsSchema = z14.object({
+  closed: z14.number().int().nonnegative(),
+  created: z14.number().int().nonnegative(),
+  juniorOnly: z14.number().int().nonnegative(),
+  merged: z14.number().int().nonnegative(),
+  repository: z14.string().min(1)
 }).strict().transform((row) => {
   const terminal = row.merged + row.closed;
   return {
@@ -2552,33 +2711,33 @@ var pullRequestRepositoryStatsSchema = z13.object({
     mergeRate: terminal > 0 ? row.merged / terminal : void 0
   };
 });
-var issueStatsSchema = z13.object({
-  closedCompleted: z13.number().int().nonnegative(),
-  closedDuplicate: z13.number().int().nonnegative(),
-  closedNotPlanned: z13.number().int().nonnegative(),
-  closedUnknown: z13.number().int().nonnegative(),
-  created: z13.number().int().nonnegative(),
-  days: z13.number().int().positive(),
-  medianCloseTimeMs: z13.number().nonnegative().nullable()
+var issueStatsSchema = z14.object({
+  closedCompleted: z14.number().int().nonnegative(),
+  closedDuplicate: z14.number().int().nonnegative(),
+  closedNotPlanned: z14.number().int().nonnegative(),
+  closedUnknown: z14.number().int().nonnegative(),
+  created: z14.number().int().nonnegative(),
+  days: z14.number().int().positive(),
+  medianCloseTimeMs: z14.number().nonnegative().nullable()
 }).strict().transform((row) => ({
   ...row,
   medianCloseTimeMs: row.medianCloseTimeMs ?? void 0
 }));
-var pullRequestDaySchema = z13.object({
-  created: z13.number().int().nonnegative(),
-  date: z13.string().date()
+var pullRequestDaySchema = z14.object({
+  created: z14.number().int().nonnegative(),
+  date: z14.string().date()
 }).strict();
-var issueDaySchema = z13.object({
-  created: z13.number().int().nonnegative(),
-  date: z13.string().date()
+var issueDaySchema = z14.object({
+  created: z14.number().int().nonnegative(),
+  date: z14.string().date()
 }).strict();
-var issueRepositoryStatsSchema = z13.object({
-  closedCompleted: z13.number().int().nonnegative(),
-  closedDuplicate: z13.number().int().nonnegative(),
-  closedNotPlanned: z13.number().int().nonnegative(),
-  closedUnknown: z13.number().int().nonnegative(),
-  created: z13.number().int().nonnegative(),
-  repository: z13.string().min(1)
+var issueRepositoryStatsSchema = z14.object({
+  closedCompleted: z14.number().int().nonnegative(),
+  closedDuplicate: z14.number().int().nonnegative(),
+  closedNotPlanned: z14.number().int().nonnegative(),
+  closedUnknown: z14.number().int().nonnegative(),
+  created: z14.number().int().nonnegative(),
+  repository: z14.string().min(1)
 }).strict();
 function queryRows2(result) {
   if (typeof result !== "object" || result === null || !("rows" in result) || !Array.isArray(result.rows)) {
@@ -2642,7 +2801,7 @@ async function aggregatePullRequestWindows(args) {
     GROUP BY windows.days
     ORDER BY windows.days
   `);
-  return z13.array(pullRequestStatsSchema).parse(queryRows2(result));
+  return z14.array(pullRequestStatsSchema).parse(queryRows2(result));
 }
 async function aggregatePullRequestDays(args) {
   const end = new Date(args.nowMs);
@@ -2670,7 +2829,7 @@ async function aggregatePullRequestDays(args) {
     LEFT JOIN daily ON daily.day = days.day
     ORDER BY days.day
   `);
-  return z13.array(pullRequestDaySchema).parse(queryRows2(result));
+  return z14.array(pullRequestDaySchema).parse(queryRows2(result));
 }
 async function aggregatePullRequestRepositories(args) {
   const start = new Date(args.nowMs - 30 * DAY_MS2);
@@ -2700,7 +2859,7 @@ async function aggregatePullRequestRepositories(args) {
     ORDER BY "merged" DESC, "created" DESC, "repository" ASC
     LIMIT 25
   `);
-  return z13.array(pullRequestRepositoryStatsSchema).parse(queryRows2(result));
+  return z14.array(pullRequestRepositoryStatsSchema).parse(queryRows2(result));
 }
 async function aggregateIssueWindows(args) {
   const starts = WINDOWS.map(
@@ -2769,7 +2928,7 @@ async function aggregateIssueWindows(args) {
     GROUP BY windows.days
     ORDER BY windows.days
   `);
-  return z13.array(issueStatsSchema).parse(queryRows2(result));
+  return z14.array(issueStatsSchema).parse(queryRows2(result));
 }
 async function aggregateIssueDays(args) {
   const end = new Date(args.nowMs);
@@ -2797,7 +2956,7 @@ async function aggregateIssueDays(args) {
     LEFT JOIN daily ON daily.day = days.day
     ORDER BY days.day
   `);
-  return z13.array(issueDaySchema).parse(queryRows2(result));
+  return z14.array(issueDaySchema).parse(queryRows2(result));
 }
 async function aggregateIssueRepositories(args) {
   const start = new Date(args.nowMs - 30 * DAY_MS2);
@@ -2834,7 +2993,7 @@ async function aggregateIssueRepositories(args) {
     ORDER BY "created" DESC, "closedCompleted" DESC, "repository" ASC
     LIMIT 25
   `);
-  return z13.array(issueRepositoryStatsSchema).parse(queryRows2(result));
+  return z14.array(issueRepositoryStatsSchema).parse(queryRows2(result));
 }
 function formatPercent(value) {
   return value === void 0 ? "\u2014" : `${Math.round(value * 100)}%`;
@@ -2998,18 +3157,18 @@ async function buildGitHubOutcomeReport(args) {
 }
 
 // src/pull-request-outcomes/commit-composition.ts
-import { z as z14 } from "zod";
-var canonicalCommitSchema = z14.object({
-  authorEmail: z14.string().nullable(),
-  authorLogin: z14.string().nullable()
+import { z as z15 } from "zod";
+var canonicalCommitSchema = z15.object({
+  authorEmail: z15.string().nullable(),
+  authorLogin: z15.string().nullable()
 }).strict();
-var providerCommitSchema = z14.object({
-  author: z14.object({ login: z14.string() }).passthrough().nullable(),
-  commit: z14.object({
-    author: z14.object({ email: z14.string() }).passthrough().nullable()
+var providerCommitSchema = z15.object({
+  author: z15.object({ login: z15.string() }).passthrough().nullable(),
+  commit: z15.object({
+    author: z15.object({ email: z15.string() }).passthrough().nullable()
   }).passthrough()
 }).passthrough();
-var commitPageSchema = z14.array(providerCommitSchema).transform(
+var commitPageSchema = z15.array(providerCommitSchema).transform(
   (commits) => commits.map(
     (commit) => canonicalCommitSchema.parse({
       authorEmail: commit.commit.author?.email ?? null,
@@ -4224,10 +4383,22 @@ function githubPlugin(options = {}) {
           supportedEvents: [...GITHUB_PULL_REQUEST_EVENTS],
           suggestedEvents: [...GITHUB_PULL_REQUEST_SUGGESTED_EVENTS]
         },
+        {
+          type: "release_source",
+          supportedEvents: [...GITHUB_RELEASE_EVENTS],
+          suggestedEvents: [...GITHUB_RELEASE_SUGGESTED_EVENTS]
+        },
         {
           type: "repository",
-          supportedEvents: [...GITHUB_ISSUE_EVENTS],
-          suggestedEvents: ["issue.opened", ...GITHUB_ISSUE_SUGGESTED_EVENTS]
+          supportedEvents: [
+            ...GITHUB_ISSUE_EVENTS,
+            ...GITHUB_PULL_REQUEST_EVENTS
+          ],
+          suggestedEvents: [
+            "issue.opened",
+            ...GITHUB_ISSUE_SUGGESTED_EVENTS,
+            ...GITHUB_PULL_REQUEST_SUGGESTED_EVENTS
+          ]
         }
       ],
       isEnabled: () => Boolean(readEnv("GITHUB_WEBHOOK_SECRET")),
@@ -4236,7 +4407,7 @@ function githubPlugin(options = {}) {
     manifest: {
       name: "github",
       displayName: "GitHub",
-      description: "GitHub deployment, issue, pull request, and repository workflows via GitHub App",
+      description: "GitHub deployment, issue, pull request, release, and repository workflows via GitHub App",
       configKeys: ["org", "repo"],
       domains: ["api.github.com", "github.com", "uploads.github.com"],
       envVars: {