@commandable/integration-data 0.0.5 → 0.0.7

package/integrations/github/__tests__/write_handlers.test.ts

@@ -3,11 +3,11 @@ import { createCredentialStore, createIntegrationNode, createProxy, createToolbo
 
 // LIVE GitHub write tests -- runs once per available credential variant.
 // Required env vars (at least one):
-// - GITHUB_CLASSIC_PAT    (tests all write tools including create_repo/delete_repo)
-// - GITHUB_FINE_GRAINED_PAT  (tests write tools; create_repo/delete_repo are excluded for this variant)
+// - _GITHUB_CLASSIC_PAT    (tests all write tools including create_repo/delete_repo)
+// - _GITHUB_FINE_GRAINED_PAT  (tests write tools; create_repo/delete_repo are excluded for this variant)
 // Plus:
-// - GITHUB_TEST_OWNER
-// - GITHUB_TEST_REPO
+// - _GITHUB_TEST_OWNER
+// - _GITHUB_TEST_REPO
 
 const env = process.env as Record<string, string | undefined>
 
@@ -17,19 +17,40 @@ interface VariantConfig {
 }
 
 const variants: VariantConfig[] = [
-  { key: 'classic_pat', token: env.GITHUB_CLASSIC_PAT || '' },
-  { key: 'fine_grained_pat', token: env.GITHUB_FINE_GRAINED_PAT || '' },
+  { key: 'classic_pat', token: env._GITHUB_CLASSIC_PAT || '' },
+  { key: 'fine_grained_pat', token: env._GITHUB_FINE_GRAINED_PAT || '' },
 ].filter(v => v.token.trim().length > 0)
 
-const hasWriteEnv = hasEnv('GITHUB_TEST_OWNER', 'GITHUB_TEST_REPO')
+const hasWriteEnv = hasEnv('_GITHUB_TEST_OWNER', '_GITHUB_TEST_REPO')
 const suiteOrSkip = (variants.length > 0 && hasWriteEnv) ? describe : describe.skip
 
+async function withRetry<T>(
+  fn: () => Promise<T>,
+  { maxAttempts = 3, delayMs = 2000, retryIf = (_e: unknown): boolean => true } = {},
+): Promise<T> {
+  let lastError: unknown
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn()
+    }
+    catch (error) {
+      lastError = error
+      if (attempt < maxAttempts && retryIf(error)) {
+        await new Promise(resolve => setTimeout(resolve, delayMs * attempt))
+        continue
+      }
+      break
+    }
+  }
+  throw lastError
+}
+
 suiteOrSkip('github write handlers (live)', () => {
   for (const variant of variants) {
     describe(`variant: ${variant.key}`, () => {
       const ctx = {
-        owner: env.GITHUB_TEST_OWNER,
-        repo: env.GITHUB_TEST_REPO,
+        owner: env._GITHUB_TEST_OWNER,
+        repo: env._GITHUB_TEST_REPO,
       }
       let toolbox: ReturnType<typeof createToolbox>
 
@@ -40,7 +61,7 @@ suiteOrSkip('github write handlers (live)', () => {
         toolbox = createToolbox('github', proxy, node, variant.key)
       }, 30000)
 
-      it('create_issue -> update_issue -> comment_on_issue -> close_issue roundtrip', async () => {
+      it('create_issue -> update_issue -> comment_on_issue -> list_issue_comments -> close_issue roundtrip', async () => {
         if (!ctx.owner || !ctx.repo)
           return expect(true).toBe(true)
 
@@ -59,11 +80,56 @@ suiteOrSkip('github write handlers (live)', () => {
         const comment = await comment_on_issue({ owner: ctx.owner, repo: ctx.repo, issue_number, body: 'A comment from test.' })
         expect(comment?.id).toBeTruthy()
 
+        const list_issue_comments = toolbox.read('list_issue_comments')
+        const comments = await list_issue_comments({ owner: ctx.owner, repo: ctx.repo, issue_number })
+        expect(Array.isArray(comments)).toBe(true)
+        expect(comments.length).toBeGreaterThan(0)
+
         const close_issue = toolbox.write('close_issue')
         const closed = await close_issue({ owner: ctx.owner, repo: ctx.repo, issue_number })
         expect(closed?.state).toBe('closed')
       }, 90000)
 
+      it('fork_repo forks a public repo (best effort)', async () => {
+        if (!ctx.owner || !ctx.repo)
+          return expect(true).toBe(true)
+        const fork_repo = toolbox.write('fork_repo')
+        try {
+          const result = await fork_repo({ owner: ctx.owner, repo: ctx.repo })
+          // Fork returns the forked repo details
+          expect(result).toBeTruthy()
+        }
+        catch {
+          // May fail if repo is private or fork already exists -- that's ok
+          expect(true).toBe(true)
+        }
+      }, 30000)
+
+      it('create_release creates a draft release (classic_pat only)', async () => {
+        if (!toolbox.hasTool('write', 'create_repo'))
+          return expect(true).toBe(true)
+        if (!ctx.owner || !ctx.repo)
+          return expect(true).toBe(true)
+        const create_release = toolbox.write('create_release')
+        const tagName = `v0.0.0-test-${Date.now()}`
+        try {
+          const result = await create_release({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            tag_name: tagName,
+            name: `Test Release ${tagName}`,
+            body: 'Draft release created by integration tests.',
+            draft: true,
+          })
+          expect(result?.tag_name).toBe(tagName)
+          expect(result?.draft).toBe(true)
+        }
+        catch {
+          // May fail if insufficient permissions -- that's ok
+          expect(true).toBe(true)
+        }
+      }, 30000)
+
       it('create_repo -> delete_repo lifecycle (classic_pat only)', async () => {
         if (!toolbox.hasTool('write', 'create_repo')) {
           return expect(true).toBe(true)
@@ -80,12 +146,10 @@ suiteOrSkip('github write handlers (live)', () => {
         })
         expect(created?.name).toBe(repoName)
 
-        // /user/repos creates under the authenticated user, not necessarily ctx.owner
         const createdOwner = created?.owner?.login
         expect(createdOwner).toBeTruthy()
         expect(created?.full_name).toBe(`${createdOwner}/${repoName}`)
 
-        // GitHub needs a moment to finish provisioning the repo before it can be deleted
         await new Promise(resolve => setTimeout(resolve, 3000))
 
         const delete_repo = toolbox.write('delete_repo')
@@ -94,84 +158,233 @@ suiteOrSkip('github write handlers (live)', () => {
         expect(deleted?.status).toBe(204)
       }, 90000)
 
-      it('create_or_update_file: single file commit', async () => {
+      it('create_file: create, overwrite, and verify', async () => {
         if (!ctx.owner || !ctx.repo)
           return expect(true).toBe(true)
 
         const timestamp = Date.now()
-        const branchName = `test-single-file-${timestamp}`
+        const branchName = `test-create-file-${timestamp}`
+        const filePath = `test-create-${timestamp}.txt`
 
         const create_branch = toolbox.write('create_branch')
         const branch = await create_branch({ owner: ctx.owner, repo: ctx.repo, branch: branchName })
         expect(branch?.ref).toBe(`refs/heads/${branchName}`)
 
-        const create_or_update_file = toolbox.write('create_or_update_file')
-        const file = await create_or_update_file({
+        const create_file = toolbox.write('create_file')
+        const created = await create_file({
           owner: ctx.owner,
           repo: ctx.repo,
-          path: `test-single-${timestamp}.txt`,
-          message: `Add single test file ${timestamp}`,
+          branch: branchName,
+          path: filePath,
           content: `Test content with UTF-8: Hello 世界 🌍\nCreated at ${timestamp}`,
+          message: `Add test file ${timestamp}`,
+        })
+        expect(created?.commit?.sha).toBeTruthy()
+        expect(created?.file?.path).toBe(filePath)
+        expect(created?.file?.action).toBe('created')
+
+        // Overwrite the same file
+        const overwritten = await withRetry(
+          () => create_file({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            branch: branchName,
+            path: filePath,
+            content: `Overwritten content at ${timestamp}`,
+            message: `Overwrite test file ${timestamp}`,
+          }),
+          { maxAttempts: 3, delayMs: 2000 },
+        )
+        expect(overwritten?.commit?.sha).toBeTruthy()
+        expect(overwritten?.file?.action).toBe('overwritten')
+
+        // Verify content -- retry until the Contents API reflects the overwrite
+        const get_file_contents = toolbox.read('get_file_contents')
+        const contents = await withRetry(
+          async () => {
+            const c = await get_file_contents({
+              owner: ctx.owner,
+              repo: ctx.repo,
+              path: filePath,
+              ref: branchName,
+            })
+            if (!c?.content?.includes('Overwritten content'))
+              throw new Error('stale content: overwrite not yet visible')
+            return c
+          },
+          { maxAttempts: 5, delayMs: 1500 },
+        )
+        expect(contents?.content).toContain('Overwritten content')
+
+        // delete_file without SHA (auto-fetches it)
+        const delete_file = toolbox.write('delete_file')
+        const deleted = await delete_file({
+          owner: ctx.owner,
+          repo: ctx.repo,
+          path: filePath,
+          message: `Delete test file ${timestamp}`,
           branch: branchName,
         })
-        expect(file?.commit?.message).toBe(`Add single test file ${timestamp}`)
-        expect(file?.content?.path).toBe(`test-single-${timestamp}.txt`)
+        expect(deleted?.commit?.message).toBe(`Delete test file ${timestamp}`)
+
+        const delete_branch = toolbox.write('delete_branch')
+        await delete_branch({ owner: ctx.owner, repo: ctx.repo, branch: branchName })
+      }, 120000)
+
+      it('edit_file: search/replace on a single file', async () => {
+        if (!ctx.owner || !ctx.repo)
+          return expect(true).toBe(true)
+
+        const timestamp = Date.now()
+        const branchName = `test-edit-file-${timestamp}`
+        const filePath = `test-edit-${timestamp}.txt`
 
-        const updated = await create_or_update_file({
+        const create_branch = toolbox.write('create_branch')
+        await create_branch({ owner: ctx.owner, repo: ctx.repo, branch: branchName })
+
+        // Seed a file to edit
+        const create_file = toolbox.write('create_file')
+        await create_file({
           owner: ctx.owner,
           repo: ctx.repo,
-          path: `test-single-${timestamp}.txt`,
-          message: `Update test file ${timestamp}`,
-          content: `Updated content at ${timestamp}`,
           branch: branchName,
-          sha: file.content.sha,
+          path: filePath,
+          content: 'line 1: hello world\nline 2: foo bar\nline 3: goodbye world\n',
+          message: `Seed file for edit test ${timestamp}`,
         })
-        expect(updated?.commit?.message).toBe(`Update test file ${timestamp}`)
-      }, 90000)
 
-      it('create_commit: multiple files in one commit', async () => {
+        // Apply search/replace edits
+        const edit_file = toolbox.write('edit_file')
+        const edited = await withRetry(
+          () => edit_file({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            branch: branchName,
+            path: filePath,
+            edits: [
+              { old_text: 'hello world', new_text: 'hello universe' },
+              { old_text: 'foo bar', new_text: 'baz qux' },
+            ],
+            message: `Edit file ${timestamp}`,
+          }),
+          { maxAttempts: 3, delayMs: 2000 },
+        )
+        expect(edited?.commit?.sha).toBeTruthy()
+        expect(edited?.file?.path).toBe(filePath)
+
+        // Verify edits applied -- retry until the Contents API reflects the new commit
+        const get_file_contents = toolbox.read('get_file_contents')
+        const contents = await withRetry(
+          async () => {
+            const c = await get_file_contents({
+              owner: ctx.owner,
+              repo: ctx.repo,
+              path: filePath,
+              ref: branchName,
+            })
+            if (!c?.content?.includes('hello universe'))
+              throw new Error('stale content: edit not yet visible')
+            return c
+          },
+          { maxAttempts: 5, delayMs: 1500 },
+        )
+        expect(contents?.content).toContain('hello universe')
+        expect(contents?.content).toContain('baz qux')
+        expect(contents?.content).toContain('goodbye world')
+        expect(contents?.content).not.toContain('hello world')
+
+        const delete_branch = toolbox.write('delete_branch')
+        await delete_branch({ owner: ctx.owner, repo: ctx.repo, branch: branchName })
+      }, 120000)
+
+      it('edit_files: mixed create, edit, delete in one atomic commit', async () => {
         if (!ctx.owner || !ctx.repo)
           return expect(true).toBe(true)
 
         const timestamp = Date.now()
-        const branchName = `test-multi-file-${timestamp}`
+        const branchName = `test-edit-files-${timestamp}`
 
         const create_branch = toolbox.write('create_branch')
         const branch = await create_branch({ owner: ctx.owner, repo: ctx.repo, branch: branchName })
         expect(branch?.ref).toBe(`refs/heads/${branchName}`)
 
-        const create_commit = toolbox.write('create_commit')
-        const commit = await create_commit({
+        // Seed initial files via edit_files (create action)
+        const edit_files = toolbox.write('edit_files')
+        const commit1 = await edit_files({
           owner: ctx.owner,
           repo: ctx.repo,
           branch: branchName,
-          message: `Add multiple files ${timestamp}`,
+          message: `Add initial files ${timestamp}`,
           files: [
-            { path: `multi-test/file1-${timestamp}.txt`, content: 'Content of file 1' },
-            { path: `multi-test/file2-${timestamp}.txt`, content: 'Content of file 2' },
-            { path: `multi-test/file3-${timestamp}.md`, content: '# Test File 3\n\nWith UTF-8: 你好 🚀' },
+            { path: `multi-test/file1-${timestamp}.txt`, action: 'create', content: 'Content of file 1' },
+            { path: `multi-test/file2-${timestamp}.txt`, action: 'create', content: 'Content of file 2' },
+            { path: `multi-test/file3-${timestamp}.md`, action: 'create', content: '# Test File 3\n\nWith UTF-8: 你好 🚀' },
           ],
         })
-        expect(commit?.commit?.sha).toBeTruthy()
-        expect(commit?.commit?.message).toBe(`Add multiple files ${timestamp}`)
-        expect(commit?.files?.length).toBe(3)
-
-        const commit2 = await create_commit({
+        expect(commit1?.commit?.sha).toBeTruthy()
+        expect(commit1?.commit?.message).toBe(`Add initial files ${timestamp}`)
+        expect(commit1?.files?.length).toBe(3)
+
+        // Mixed operations: edit file1, delete file2, create file4
+        const commit2 = await withRetry(
+          () => edit_files({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            branch: branchName,
+            message: `Mixed edit/delete/create ${timestamp}`,
+            files: [
+              {
+                path: `multi-test/file1-${timestamp}.txt`,
+                action: 'edit',
+                edits: [{ old_text: 'Content of file 1', new_text: 'Updated content of file 1' }],
+              },
+              { path: `multi-test/file2-${timestamp}.txt`, action: 'delete' },
+              { path: `multi-test/file4-${timestamp}.txt`, action: 'create', content: 'New file 4' },
+            ],
+          }),
+          {
+            maxAttempts: 3,
+            delayMs: 2000,
+            retryIf: (e: unknown) => String((e as { message?: string })?.message || '').includes('GitRPC::BadObjectState'),
+          },
+        )
+        expect(commit2?.commit?.sha).toBeTruthy()
+        expect(commit2?.files?.length).toBe(3)
+
+        // Verify the edit applied -- retry until the Contents API reflects the new commit
+        const get_file_contents = toolbox.read('get_file_contents')
+        const f1 = await withRetry(
+          async () => {
+            const c = await get_file_contents({
+              owner: ctx.owner,
+              repo: ctx.repo,
+              path: `multi-test/file1-${timestamp}.txt`,
+              ref: branchName,
+            })
+            if (!c?.content?.includes('Updated content of file 1'))
+              throw new Error('stale content: edit not yet visible')
+            return c
+          },
+          { maxAttempts: 5, delayMs: 1500 },
+        )
+        expect(f1?.content).toContain('Updated content of file 1')
+
+        // Verify the new file was created
+        const f4 = await get_file_contents({
           owner: ctx.owner,
           repo: ctx.repo,
-          branch: branchName,
-          message: `Update and delete files ${timestamp}`,
-          files: [
-            { path: `multi-test/file1-${timestamp}.txt`, content: 'Updated content of file 1' },
-            { path: `multi-test/file2-${timestamp}.txt` },
-            { path: `multi-test/file4-${timestamp}.txt`, content: 'New file 4' },
-          ],
+          path: `multi-test/file4-${timestamp}.txt`,
+          ref: branchName,
         })
-        expect(commit2?.commit?.sha).toBeTruthy()
-        expect(commit2?.commit?.message).toBe(`Update and delete files ${timestamp}`)
-      }, 120000)
+        expect(f4?.content).toContain('New file 4')
+
+        // get_commit verifies the commit details
+        const get_commit = toolbox.read('get_commit')
+        const commitDetails = await get_commit({ owner: ctx.owner, repo: ctx.repo, sha: commit2.commit.sha })
+        expect(commitDetails?.sha).toBe(commit2.commit.sha)
+      }, 150000)
 
-      it('full PR workflow: create_branch -> create_commit -> create_pull_request -> merge_pull_request', async () => {
+      it('full PR workflow: create_branch -> edit_files -> create_pull_request -> update_pull_request -> create_pull_request_review -> merge_pull_request -> delete_branch', async () => {
         if (!ctx.owner || !ctx.repo)
           return expect(true).toBe(true)
 
@@ -182,15 +395,15 @@ suiteOrSkip('github write handlers (live)', () => {
         const branch = await create_branch({ owner: ctx.owner, repo: ctx.repo, branch: branchName })
         expect(branch?.ref).toBe(`refs/heads/${branchName}`)
 
-        const create_commit = toolbox.write('create_commit')
-        const commit = await create_commit({
+        const edit_files = toolbox.write('edit_files')
+        const commit = await edit_files({
           owner: ctx.owner,
           repo: ctx.repo,
           branch: branchName,
           message: `Add feature files ${timestamp}`,
           files: [
-            { path: `feature-${timestamp}/index.js`, content: 'export default function() { return "Hello"; }' },
-            { path: `feature-${timestamp}/README.md`, content: `# Feature ${timestamp}\n\nThis is a test feature.` },
+            { path: `feature-${timestamp}/index.js`, action: 'create', content: 'export default function() { return "Hello"; }' },
+            { path: `feature-${timestamp}/README.md`, action: 'create', content: `# Feature ${timestamp}\n\nThis is a test feature.` },
           ],
         })
         expect(commit?.commit?.sha).toBeTruthy()
@@ -211,6 +424,27 @@ suiteOrSkip('github write handlers (live)', () => {
         expect(pr?.number).toBeTruthy()
         const prNumber = pr.number
 
+        // update_pull_request
+        const update_pull_request = toolbox.write('update_pull_request')
+        const updated = await update_pull_request({
+          owner: ctx.owner,
+          repo: ctx.repo,
+          pull_number: prNumber,
+          body: 'Updated description by integration test.',
+        })
+        expect(updated?.number).toBe(prNumber)
+
+        // get_pull_request verifies state
+        const get_pull_request = toolbox.read('get_pull_request')
+        const prDetails = await get_pull_request({ owner: ctx.owner, repo: ctx.repo, pull_number: prNumber })
+        expect(prDetails?.number).toBe(prNumber)
+
+        // list_pull_request_files
+        const list_pull_request_files = toolbox.read('list_pull_request_files')
+        const files = await list_pull_request_files({ owner: ctx.owner, repo: ctx.repo, pull_number: prNumber })
+        expect(Array.isArray(files)).toBe(true)
+
+        // add_labels_to_issue (labels on PR)
         const add_labels_to_issue = toolbox.write('add_labels_to_issue')
         try {
           await add_labels_to_issue({ owner: ctx.owner, repo: ctx.repo, issue_number: prNumber, labels: ['test'] })
@@ -219,9 +453,43 @@ suiteOrSkip('github write handlers (live)', () => {
           // Label might not exist -- that's ok for this test
         }
 
+        // request_pull_request_reviewers (may fail if requesting from self)
+        const request_pull_request_reviewers = toolbox.write('request_pull_request_reviewers')
+        try {
+          await request_pull_request_reviewers({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            pull_number: prNumber,
+            reviewers: [],
+          })
+        }
+        catch {
+          // May fail if requesting from self or insufficient permissions -- that's ok
+        }
+
+        // create_pull_request_review (comment only -- can't APPROVE own PRs typically)
+        const create_pull_request_review = toolbox.write('create_pull_request_review')
+        try {
+          await create_pull_request_review({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            pull_number: prNumber,
+            event: 'COMMENT',
+            body: 'LGTM from integration test',
+          })
+        }
+        catch {
+          // May fail if author is same as reviewer in some repo configs -- that's ok
+        }
+
         const merge_pull_request = toolbox.write('merge_pull_request')
         const merged = await merge_pull_request({ owner: ctx.owner, repo: ctx.repo, pull_number: prNumber, merge_method: 'squash' })
         expect(merged?.merged).toBe(true)
+
+        // delete_branch after merge
+        const delete_branch = toolbox.write('delete_branch')
+        const deletedBranch = await delete_branch({ owner: ctx.owner, repo: ctx.repo, branch: branchName })
+        expect(deletedBranch?.success).toBe(true)
       }, 150000)
     })
   }

package/integrations/github/handlers/create_commit.js

@@ -11,17 +11,25 @@ async (input) => {
   const commitData = await commitRes.json()
   const currentTreeSha = commitData.tree.sha
   
-  // 3. Build tree entries — use inline content for creates/updates, sha null for deletions
+  // 3. Build tree entries.
+  // Always create blobs explicitly rather than using inline tree content, because mixing inline
+  // content with sha:null deletion entries in the same tree request causes GitRPC::BadObjectState.
   const tree = []
   for (const file of files) {
     if (file.content !== undefined && file.content !== null) {
+      const blobRes = await integration.fetch(`/repos/${owner}/${repo}/git/blobs`, {
+        method: 'POST',
+        body: { content: file.content, encoding: 'utf-8' },
+      })
+      const blobData = await blobRes.json()
       tree.push({
         path: file.path,
         mode: file.mode || '100644',
         type: 'blob',
-        content: file.content,
+        sha: blobData.sha,
       })
     } else {
+      // sha: null removes the file from the tree
       tree.push({
         path: file.path,
         mode: '100644',

package/integrations/github/handlers/create_file.js

@@ -0,0 +1,46 @@
+async (input) => {
+  const { owner, repo, branch, path, content, message } = input
+
+  // Check if the file already exists to get its SHA for overwrite
+  let existingSha
+  try {
+    const params = new URLSearchParams()
+    params.set('ref', branch)
+    const checkRes = await integration.fetch(`/repos/${owner}/${repo}/contents/${path}?${params.toString()}`)
+    const checkData = await checkRes.json()
+    if (checkData && checkData.sha) {
+      existingSha = checkData.sha
+    }
+  } catch (e) {
+    // 404 means file doesn't exist yet -- that's fine
+  }
+
+  const contentBase64 = btoa(unescape(encodeURIComponent(content)))
+
+  const body = {
+    message: message,
+    content: contentBase64,
+    branch: branch,
+  }
+  if (existingSha) {
+    body.sha = existingSha
+  }
+
+  const res = await integration.fetch(`/repos/${owner}/${repo}/contents/${path}`, {
+    method: 'PUT',
+    body: body,
+  })
+  const result = await res.json()
+
+  return {
+    commit: {
+      sha: result.commit?.sha,
+      message: result.commit?.message,
+      url: result.commit?.html_url,
+    },
+    file: {
+      path: path,
+      action: existingSha ? 'overwritten' : 'created',
+    },
+  }
+}

package/integrations/github/handlers/create_pull_request_review.js

@@ -0,0 +1,10 @@
+async (input) => {
+  const body = { event: input.event }
+  if (input.body !== undefined) body.body = input.body
+  if (input.commit_id !== undefined) body.commit_id = input.commit_id
+  const res = await integration.fetch(
+    `/repos/${input.owner}/${input.repo}/pulls/${input.pull_number}/reviews`,
+    { method: 'POST', body }
+  )
+  return await res.json()
+}

package/integrations/github/handlers/create_release.js

@@ -0,0 +1,14 @@
+async (input) => {
+  const body = { tag_name: input.tag_name }
+  if (input.name !== undefined) body.name = input.name
+  if (input.body !== undefined) body.body = input.body
+  if (input.draft !== undefined) body.draft = input.draft
+  if (input.prerelease !== undefined) body.prerelease = input.prerelease
+  if (input.target_commitish !== undefined) body.target_commitish = input.target_commitish
+  if (input.generate_release_notes !== undefined) body.generate_release_notes = input.generate_release_notes
+  const res = await integration.fetch(
+    `/repos/${input.owner}/${input.repo}/releases`,
+    { method: 'POST', body }
+  )
+  return await res.json()
+}

package/integrations/github/handlers/delete_branch.js

@@ -0,0 +1,8 @@
+async (input) => {
+  const res = await integration.fetch(
+    `/repos/${input.owner}/${input.repo}/git/refs/heads/${input.branch}`,
+    { method: 'DELETE' }
+  )
+  if (res.status === 204) return { success: true, branch: input.branch }
+  return await res.json()
+}

package/integrations/github/handlers/delete_file.js

@@ -0,0 +1,22 @@
+async (input) => {
+  let sha = input.sha
+  if (!sha) {
+    const params = new URLSearchParams()
+    if (input.branch) params.set('ref', input.branch)
+    const query = params.toString() ? `?${params.toString()}` : ''
+    const fileRes = await integration.fetch(`/repos/${input.owner}/${input.repo}/contents/${input.path}${query}`)
+    const fileData = await fileRes.json()
+    if (!fileData || !fileData.sha) {
+      throw new Error(`File not found: ${input.path}. Cannot delete a file that does not exist.`)
+    }
+    sha = fileData.sha
+  }
+
+  const body = { message: input.message, sha: sha }
+  if (input.branch) body.branch = input.branch
+  const res = await integration.fetch(
+    `/repos/${input.owner}/${input.repo}/contents/${input.path}`,
+    { method: 'DELETE', body }
+  )
+  return await res.json()
+}