@slates-integrations/github 0.2.0-rc.2

package/src/tools/search.ts

@@ -0,0 +1,72 @@
+import { SlateTool } from 'slates';
+import { GitHubClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let search = SlateTool.create(spec, {
+  name: 'Search GitHub',
+  key: 'search',
+  description: `Search across GitHub for repositories, code, issues/pull requests, or users using GitHub's search syntax.
+Supports qualifiers for filtering (e.g., "language:python stars:>100" for repositories).`,
+  instructions: [
+    'Use GitHub search qualifiers in the query for precise results (e.g., "repo:owner/name", "language:go", "is:pr is:merged").',
+    'For issues vs PRs, use "is:issue" or "is:pr" qualifier in the query when searching type "issues".'
+  ],
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      type: z
+        .enum(['repositories', 'code', 'issues', 'users'])
+        .describe('Type of resource to search'),
+      query: z.string().describe('Search query with optional GitHub search qualifiers'),
+      sort: z
+        .string()
+        .optional()
+        .describe('Sort field (varies by type, e.g., "stars", "updated", "comments")'),
+      order: z.enum(['asc', 'desc']).optional().describe('Sort order'),
+      perPage: z.number().optional().describe('Results per page (max 100)'),
+      page: z.number().optional().describe('Page number')
+    })
+  )
+  .output(
+    z.object({
+      totalCount: z.number().describe('Total number of matching results'),
+      incompleteResults: z.boolean().describe('Whether results may be incomplete'),
+      items: z
+        .array(z.record(z.string(), z.any()))
+        .describe('Search result items (shape depends on search type)')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new GitHubClient(ctx.auth.token);
+    let { type, query, ...params } = ctx.input;
+    let result: any;
+
+    switch (type) {
+      case 'repositories':
+        result = await client.searchRepositories(query, params);
+        break;
+      case 'code':
+        result = await client.searchCode(query, params);
+        break;
+      case 'issues':
+        result = await client.searchIssues(query, params);
+        break;
+      case 'users':
+        result = await client.searchUsers(query, params);
+        break;
+    }
+
+    return {
+      output: {
+        totalCount: result.total_count,
+        incompleteResults: result.incomplete_results,
+        items: result.items
+      },
+      message: `Found **${result.total_count}** results for "${query}" (${type}).`
+    };
+  })
+  .build();

package/src/tools/star-repository.ts

@@ -0,0 +1,57 @@
+import { SlateTool } from 'slates';
+import { GitHubClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let starRepository = SlateTool.create(spec, {
+  name: 'Star Repository',
+  key: 'star_repository',
+  description: `Star or unstar a GitHub repository for the authenticated user.`
+})
+  .input(
+    z.object({
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      action: z.enum(['star', 'unstar']).describe('Whether to star or unstar the repository')
+    })
+  )
+  .output(
+    z.object({
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      fullName: z.string().describe('Repository full name'),
+      htmlUrl: z.string().describe('Repository URL'),
+      starred: z.boolean().describe('Whether the repository is starred after this action')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new GitHubClient(ctx.auth.token);
+    let { owner, repo, action } = ctx.input;
+
+    if (action === 'star') {
+      await client.starRepository(owner, repo);
+      return {
+        output: {
+          owner,
+          repo,
+          fullName: `${owner}/${repo}`,
+          htmlUrl: `https://github.com/${owner}/${repo}`,
+          starred: true
+        },
+        message: `Starred **${owner}/${repo}**.`
+      };
+    }
+
+    await client.unstarRepository(owner, repo);
+    return {
+      output: {
+        owner,
+        repo,
+        fullName: `${owner}/${repo}`,
+        htmlUrl: `https://github.com/${owner}/${repo}`,
+        starred: false
+      },
+      message: `Removed star from **${owner}/${repo}**.`
+    };
+  })
+  .build();

package/src/tools/update-repository.ts

@@ -0,0 +1,56 @@
+import { SlateTool } from 'slates';
+import { GitHubClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let updateRepository = SlateTool.create(spec, {
+  name: 'Update Repository',
+  key: 'update_repository',
+  description: `Update settings of an existing GitHub repository.
+Modify name, description, visibility, feature toggles (issues, wiki, projects), default branch, and archive status.`
+})
+  .input(
+    z.object({
+      owner: z.string().describe('Repository owner (user or organization)'),
+      repo: z.string().describe('Repository name'),
+      name: z.string().optional().describe('New repository name'),
+      description: z.string().optional().describe('New description'),
+      homepage: z.string().optional().describe('Homepage URL'),
+      private: z.boolean().optional().describe('Set repository visibility'),
+      hasIssues: z.boolean().optional().describe('Enable or disable issues'),
+      hasProjects: z.boolean().optional().describe('Enable or disable projects'),
+      hasWiki: z.boolean().optional().describe('Enable or disable wiki'),
+      defaultBranch: z.string().optional().describe('Change default branch'),
+      archived: z.boolean().optional().describe('Archive or unarchive the repository')
+    })
+  )
+  .output(
+    z.object({
+      repositoryId: z.number().describe('Unique repository ID'),
+      name: z.string().describe('Repository name'),
+      fullName: z.string().describe('Full name in owner/repo format'),
+      htmlUrl: z.string().describe('URL to the repository on GitHub'),
+      private: z.boolean().describe('Whether the repository is private'),
+      defaultBranch: z.string().describe('Default branch name'),
+      archived: z.boolean().describe('Whether the repository is archived')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new GitHubClient(ctx.auth.token);
+    let { owner, repo, ...updateData } = ctx.input;
+    let updated = await client.updateRepository(owner, repo, updateData);
+
+    return {
+      output: {
+        repositoryId: updated.id,
+        name: updated.name,
+        fullName: updated.full_name,
+        htmlUrl: updated.html_url,
+        private: updated.private,
+        defaultBranch: updated.default_branch,
+        archived: updated.archived
+      },
+      message: `Updated repository **${updated.full_name}**.`
+    };
+  })
+  .build();

package/src/triggers/index.ts

@@ -0,0 +1,8 @@
+export * from './push';
+export * from './pull-request';
+export * from './pull-request-review';
+export * from './issues';
+export * from './issue-comment';
+export * from './workflow-run';
+export * from './release';
+export * from './star';

package/src/triggers/issue-comment.ts

@@ -0,0 +1,94 @@
+import { SlateTrigger } from 'slates';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let issueCommentTrigger = SlateTrigger.create(spec, {
+  name: 'Issue Comment',
+  key: 'issue_comment',
+  description:
+    'Triggered when a comment is created, edited, or deleted on an issue or pull request.'
+})
+  .input(
+    z.object({
+      action: z.string().describe('Comment event action (created, edited, deleted)'),
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      issueNumber: z.number().describe('Issue or PR number'),
+      issueTitle: z.string().describe('Issue or PR title'),
+      isPullRequest: z.boolean().describe('Whether the comment is on a pull request'),
+      commentId: z.number().describe('Comment ID'),
+      commentBody: z.string().describe('Comment body'),
+      commentAuthor: z.string().describe('Comment author login'),
+      commentHtmlUrl: z.string().describe('URL to the comment'),
+      commentCreatedAt: z.string().describe('Comment creation timestamp'),
+      deliveryId: z.string().describe('Webhook delivery ID')
+    })
+  )
+  .output(
+    z.object({
+      action: z.string().describe('Comment event action'),
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      issueNumber: z.number().describe('Issue or PR number'),
+      issueTitle: z.string().describe('Issue or PR title'),
+      isPullRequest: z.boolean().describe('Whether the comment is on a pull request'),
+      commentId: z.number().describe('Comment ID'),
+      commentBody: z.string().describe('Comment body'),
+      commentAuthor: z.string().describe('Comment author login'),
+      commentHtmlUrl: z.string().describe('URL to the comment'),
+      commentCreatedAt: z.string().describe('Comment creation timestamp')
+    })
+  )
+  .webhook({
+    handleRequest: async ctx => {
+      let event = ctx.request.headers.get('x-github-event');
+      if (event !== 'issue_comment') {
+        return { inputs: [] };
+      }
+
+      let data = (await ctx.request.json()) as any;
+      let comment = data.comment;
+      let issue = data.issue;
+      let deliveryId = ctx.request.headers.get('x-github-delivery') ?? '';
+
+      return {
+        inputs: [
+          {
+            action: data.action,
+            owner: data.repository.owner.login,
+            repo: data.repository.name,
+            issueNumber: issue.number,
+            issueTitle: issue.title,
+            isPullRequest: !!issue.pull_request,
+            commentId: comment.id,
+            commentBody: comment.body,
+            commentAuthor: comment.user.login,
+            commentHtmlUrl: comment.html_url,
+            commentCreatedAt: comment.created_at,
+            deliveryId
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: `issue_comment.${ctx.input.action}`,
+        id: ctx.input.deliveryId,
+        output: {
+          action: ctx.input.action,
+          owner: ctx.input.owner,
+          repo: ctx.input.repo,
+          issueNumber: ctx.input.issueNumber,
+          issueTitle: ctx.input.issueTitle,
+          isPullRequest: ctx.input.isPullRequest,
+          commentId: ctx.input.commentId,
+          commentBody: ctx.input.commentBody,
+          commentAuthor: ctx.input.commentAuthor,
+          commentHtmlUrl: ctx.input.commentHtmlUrl,
+          commentCreatedAt: ctx.input.commentCreatedAt
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/issues.ts

@@ -0,0 +1,111 @@
+import { SlateTrigger } from 'slates';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let issuesTrigger = SlateTrigger.create(spec, {
+  name: 'Issues',
+  key: 'issues',
+  description:
+    'Triggered for issue activity including opened, edited, closed, assigned, labeled, milestoned, and more.'
+})
+  .input(
+    z.object({
+      action: z
+        .string()
+        .describe('Issue event action (e.g., opened, closed, edited, labeled)'),
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      issueNumber: z.number().describe('Issue number'),
+      title: z.string().describe('Issue title'),
+      body: z.string().nullable().describe('Issue body'),
+      state: z.string().describe('Issue state'),
+      author: z.string().describe('Issue author login'),
+      htmlUrl: z.string().describe('URL to the issue'),
+      labels: z.array(z.string()).describe('Label names'),
+      assignees: z.array(z.string()).describe('Assigned usernames'),
+      milestoneName: z.string().nullable().describe('Milestone title'),
+      createdAt: z.string().describe('Creation timestamp'),
+      updatedAt: z.string().describe('Last update timestamp'),
+      closedAt: z.string().nullable().describe('Closure timestamp'),
+      deliveryId: z.string().describe('Webhook delivery ID')
+    })
+  )
+  .output(
+    z.object({
+      action: z.string().describe('Issue event action'),
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      issueNumber: z.number().describe('Issue number'),
+      title: z.string().describe('Issue title'),
+      body: z.string().nullable().describe('Issue body'),
+      state: z.string().describe('Issue state'),
+      author: z.string().describe('Issue author login'),
+      htmlUrl: z.string().describe('URL to the issue'),
+      labels: z.array(z.string()).describe('Label names'),
+      assignees: z.array(z.string()).describe('Assigned usernames'),
+      milestoneName: z.string().nullable().describe('Milestone title'),
+      createdAt: z.string().describe('Creation timestamp'),
+      updatedAt: z.string().describe('Last update timestamp'),
+      closedAt: z.string().nullable().describe('Closure timestamp')
+    })
+  )
+  .webhook({
+    handleRequest: async ctx => {
+      let event = ctx.request.headers.get('x-github-event');
+      if (event !== 'issues') {
+        return { inputs: [] };
+      }
+
+      let data = (await ctx.request.json()) as any;
+      let issue = data.issue;
+      let deliveryId = ctx.request.headers.get('x-github-delivery') ?? '';
+
+      return {
+        inputs: [
+          {
+            action: data.action,
+            owner: data.repository.owner.login,
+            repo: data.repository.name,
+            issueNumber: issue.number,
+            title: issue.title,
+            body: issue.body,
+            state: issue.state,
+            author: issue.user.login,
+            htmlUrl: issue.html_url,
+            labels: (issue.labels ?? []).map((l: any) => l.name),
+            assignees: (issue.assignees ?? []).map((a: any) => a.login),
+            milestoneName: issue.milestone?.title ?? null,
+            createdAt: issue.created_at,
+            updatedAt: issue.updated_at,
+            closedAt: issue.closed_at ?? null,
+            deliveryId
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: `issue.${ctx.input.action}`,
+        id: ctx.input.deliveryId,
+        output: {
+          action: ctx.input.action,
+          owner: ctx.input.owner,
+          repo: ctx.input.repo,
+          issueNumber: ctx.input.issueNumber,
+          title: ctx.input.title,
+          body: ctx.input.body,
+          state: ctx.input.state,
+          author: ctx.input.author,
+          htmlUrl: ctx.input.htmlUrl,
+          labels: ctx.input.labels,
+          assignees: ctx.input.assignees,
+          milestoneName: ctx.input.milestoneName,
+          createdAt: ctx.input.createdAt,
+          updatedAt: ctx.input.updatedAt,
+          closedAt: ctx.input.closedAt
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/pull-request-review.ts

@@ -0,0 +1,95 @@
+import { SlateTrigger } from 'slates';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let pullRequestReviewTrigger = SlateTrigger.create(spec, {
+  name: 'Pull Request Review',
+  key: 'pull_request_review',
+  description: 'Triggered when a pull request review is submitted, edited, or dismissed.'
+})
+  .input(
+    z.object({
+      action: z.string().describe('Review event action (submitted, edited, dismissed)'),
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      pullNumber: z.number().describe('Pull request number'),
+      pullTitle: z.string().describe('Pull request title'),
+      reviewId: z.number().describe('Review ID'),
+      reviewState: z
+        .string()
+        .describe('Review state (approved, changes_requested, commented, dismissed)'),
+      reviewBody: z.string().nullable().describe('Review body'),
+      reviewer: z.string().describe('Reviewer login'),
+      reviewHtmlUrl: z.string().describe('URL to the review'),
+      submittedAt: z.string().nullable().describe('Submission timestamp'),
+      deliveryId: z.string().describe('Webhook delivery ID')
+    })
+  )
+  .output(
+    z.object({
+      action: z.string().describe('Review event action'),
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      pullNumber: z.number().describe('Pull request number'),
+      pullTitle: z.string().describe('Pull request title'),
+      reviewId: z.number().describe('Review ID'),
+      reviewState: z.string().describe('Review state'),
+      reviewBody: z.string().nullable().describe('Review body'),
+      reviewer: z.string().describe('Reviewer login'),
+      reviewHtmlUrl: z.string().describe('URL to the review'),
+      submittedAt: z.string().nullable().describe('Submission timestamp')
+    })
+  )
+  .webhook({
+    handleRequest: async ctx => {
+      let event = ctx.request.headers.get('x-github-event');
+      if (event !== 'pull_request_review') {
+        return { inputs: [] };
+      }
+
+      let data = (await ctx.request.json()) as any;
+      let review = data.review;
+      let pr = data.pull_request;
+      let deliveryId = ctx.request.headers.get('x-github-delivery') ?? '';
+
+      return {
+        inputs: [
+          {
+            action: data.action,
+            owner: data.repository.owner.login,
+            repo: data.repository.name,
+            pullNumber: pr.number,
+            pullTitle: pr.title,
+            reviewId: review.id,
+            reviewState: review.state,
+            reviewBody: review.body,
+            reviewer: review.user.login,
+            reviewHtmlUrl: review.html_url,
+            submittedAt: review.submitted_at ?? null,
+            deliveryId
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: `pull_request_review.${ctx.input.action}`,
+        id: ctx.input.deliveryId,
+        output: {
+          action: ctx.input.action,
+          owner: ctx.input.owner,
+          repo: ctx.input.repo,
+          pullNumber: ctx.input.pullNumber,
+          pullTitle: ctx.input.pullTitle,
+          reviewId: ctx.input.reviewId,
+          reviewState: ctx.input.reviewState,
+          reviewBody: ctx.input.reviewBody,
+          reviewer: ctx.input.reviewer,
+          reviewHtmlUrl: ctx.input.reviewHtmlUrl,
+          submittedAt: ctx.input.submittedAt
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/pull-request.ts

@@ -0,0 +1,123 @@
+import { SlateTrigger } from 'slates';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let pullRequestTrigger = SlateTrigger.create(spec, {
+  name: 'Pull Request',
+  key: 'pull_request',
+  description:
+    'Triggered for pull request activity including opened, closed, merged, assigned, labeled, review requested, synchronized, and more.'
+})
+  .input(
+    z.object({
+      action: z
+        .string()
+        .describe('PR event action (e.g., opened, closed, synchronize, labeled)'),
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      pullNumber: z.number().describe('Pull request number'),
+      title: z.string().describe('PR title'),
+      body: z.string().nullable().describe('PR body'),
+      state: z.string().describe('PR state'),
+      author: z.string().describe('PR author login'),
+      head: z.string().describe('Head branch ref'),
+      base: z.string().describe('Base branch ref'),
+      htmlUrl: z.string().describe('URL to the PR'),
+      draft: z.boolean().describe('Whether the PR is a draft'),
+      merged: z.boolean().describe('Whether the PR was merged'),
+      mergedBy: z.string().nullable().describe('User who merged the PR'),
+      labels: z.array(z.string()).describe('Label names'),
+      assignees: z.array(z.string()).describe('Assigned usernames'),
+      createdAt: z.string().describe('Creation timestamp'),
+      updatedAt: z.string().describe('Last update timestamp'),
+      deliveryId: z.string().describe('Webhook delivery ID')
+    })
+  )
+  .output(
+    z.object({
+      action: z.string().describe('PR event action'),
+      owner: z.string().describe('Repository owner'),
+      repo: z.string().describe('Repository name'),
+      pullNumber: z.number().describe('Pull request number'),
+      title: z.string().describe('PR title'),
+      body: z.string().nullable().describe('PR body'),
+      state: z.string().describe('PR state'),
+      author: z.string().describe('PR author login'),
+      head: z.string().describe('Head branch ref'),
+      base: z.string().describe('Base branch ref'),
+      htmlUrl: z.string().describe('URL to the PR'),
+      draft: z.boolean().describe('Whether the PR is a draft'),
+      merged: z.boolean().describe('Whether the PR was merged'),
+      mergedBy: z.string().nullable().describe('User who merged the PR'),
+      labels: z.array(z.string()).describe('Label names'),
+      assignees: z.array(z.string()).describe('Assigned usernames'),
+      createdAt: z.string().describe('Creation timestamp'),
+      updatedAt: z.string().describe('Last update timestamp')
+    })
+  )
+  .webhook({
+    handleRequest: async ctx => {
+      let event = ctx.request.headers.get('x-github-event');
+      if (event !== 'pull_request') {
+        return { inputs: [] };
+      }
+
+      let data = (await ctx.request.json()) as any;
+      let pr = data.pull_request;
+      let deliveryId = ctx.request.headers.get('x-github-delivery') ?? '';
+
+      return {
+        inputs: [
+          {
+            action: data.action,
+            owner: data.repository.owner.login,
+            repo: data.repository.name,
+            pullNumber: pr.number,
+            title: pr.title,
+            body: pr.body,
+            state: pr.state,
+            author: pr.user.login,
+            head: pr.head.ref,
+            base: pr.base.ref,
+            htmlUrl: pr.html_url,
+            draft: pr.draft ?? false,
+            merged: pr.merged ?? false,
+            mergedBy: pr.merged_by?.login ?? null,
+            labels: (pr.labels ?? []).map((l: any) => l.name),
+            assignees: (pr.assignees ?? []).map((a: any) => a.login),
+            createdAt: pr.created_at,
+            updatedAt: pr.updated_at,
+            deliveryId
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: `pull_request.${ctx.input.action}`,
+        id: ctx.input.deliveryId,
+        output: {
+          action: ctx.input.action,
+          owner: ctx.input.owner,
+          repo: ctx.input.repo,
+          pullNumber: ctx.input.pullNumber,
+          title: ctx.input.title,
+          body: ctx.input.body,
+          state: ctx.input.state,
+          author: ctx.input.author,
+          head: ctx.input.head,
+          base: ctx.input.base,
+          htmlUrl: ctx.input.htmlUrl,
+          draft: ctx.input.draft,
+          merged: ctx.input.merged,
+          mergedBy: ctx.input.mergedBy,
+          labels: ctx.input.labels,
+          assignees: ctx.input.assignees,
+          createdAt: ctx.input.createdAt,
+          updatedAt: ctx.input.updatedAt
+        }
+      };
+    }
+  })
+  .build();