@slates-integrations/github 0.2.0-rc.4 → 0.2.0-rc.9

package/src/spec.ts

@@ -1,13 +0,0 @@
-import { SlateSpecification } from 'slates';
-import { auth } from './auth';
-import { config } from './config';
-
-export let spec = SlateSpecification.create({
-  key: 'github',
-  name: 'GitHub',
-  description:
-    'Cloud-based platform for version control and collaboration using Git. Provides repository hosting, issue tracking, pull requests, code review, CI/CD with GitHub Actions, and project management.',
-  metadata: {},
-  config,
-  auth
-});

package/src/tools/comment-on-issue.ts

@@ -1,46 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let commentOnIssue = SlateTool.create(spec, {
-  name: 'Comment on Issue',
-  key: 'comment_on_issue',
-  description: `Add a comment to an existing issue or pull request. Both issues and pull requests share the same comment API.`
-})
-  .input(
-    z.object({
-      owner: z.string().describe('Repository owner (user or organization)'),
-      repo: z.string().describe('Repository name'),
-      issueNumber: z.number().describe('Issue or pull request number'),
-      body: z.string().describe('Comment body in Markdown')
-    })
-  )
-  .output(
-    z.object({
-      commentId: z.number().describe('Unique comment ID'),
-      htmlUrl: z.string().describe('URL to the comment on GitHub'),
-      author: z.string().describe('Comment author login'),
-      createdAt: z.string().describe('Creation timestamp')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let comment = await client.createIssueComment(
-      ctx.input.owner,
-      ctx.input.repo,
-      ctx.input.issueNumber,
-      ctx.input.body
-    );
-
-    return {
-      output: {
-        commentId: comment.id,
-        htmlUrl: comment.html_url,
-        author: comment.user.login,
-        createdAt: comment.created_at
-      },
-      message: `Added comment on **#${ctx.input.issueNumber}** in **${ctx.input.owner}/${ctx.input.repo}** — ${comment.html_url}`
-    };
-  })
-  .build();

package/src/tools/create-commit-status.ts

@@ -1,97 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let createCommitStatus = SlateTool.create(spec, {
-  name: 'Create Commit Status',
-  key: 'create_commit_status',
-  description: `Create a status check on a specific commit. Useful for integrating CI/CD results, deployment status, or other external checks.
-Also supports reading the combined status of all checks for a given ref.`,
-  instructions: [
-    'Use action "create" to set a status on a commit SHA.',
-    'Use action "get" to retrieve the combined status for a ref (branch, tag, or SHA).'
-  ]
-})
-  .input(
-    z.object({
-      owner: z.string().describe('Repository owner'),
-      repo: z.string().describe('Repository name'),
-      action: z.enum(['create', 'get']).describe('Action to perform'),
-      ref: z.string().describe('Commit SHA (for create) or branch/tag/SHA (for get)'),
-      state: z
-        .enum(['error', 'failure', 'pending', 'success'])
-        .optional()
-        .describe('Status state (required for create)'),
-      targetUrl: z.string().optional().describe('URL to link from the status (for create)'),
-      description: z
-        .string()
-        .optional()
-        .describe('Short description of the status (for create)'),
-      context: z
-        .string()
-        .optional()
-        .describe('Label to differentiate statuses (for create, default: "default")')
-    })
-  )
-  .output(
-    z.object({
-      state: z.string().describe('Status state'),
-      totalCount: z.number().optional().describe('Total number of statuses (for get)'),
-      statuses: z
-        .array(
-          z.object({
-            state: z.string(),
-            context: z.string(),
-            description: z.string().nullable(),
-            targetUrl: z.string().nullable(),
-            createdAt: z.string()
-          })
-        )
-        .optional()
-        .describe('Individual statuses (for get)'),
-      statusId: z.number().optional().describe('Created status ID'),
-      htmlUrl: z.string().optional().describe('URL to the status')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let { owner, repo, action, ref } = ctx.input;
-
-    if (action === 'get') {
-      let combined = await client.getCombinedStatus(owner, repo, ref);
-      return {
-        output: {
-          state: combined.state,
-          totalCount: combined.total_count,
-          statuses: combined.statuses.map((s: any) => ({
-            state: s.state,
-            context: s.context,
-            description: s.description,
-            targetUrl: s.target_url,
-            createdAt: s.created_at
-          }))
-        },
-        message: `Combined status for \`${ref}\`: **${combined.state}** (${combined.total_count} checks).`
-      };
-    }
-
-    if (!ctx.input.state) throw new Error('state is required for create action.');
-
-    let status = await client.createCommitStatus(owner, repo, ref, {
-      state: ctx.input.state,
-      targetUrl: ctx.input.targetUrl,
-      description: ctx.input.description,
-      context: ctx.input.context
-    });
-
-    return {
-      output: {
-        state: status.state,
-        statusId: status.id,
-        htmlUrl: status.url
-      },
-      message: `Set commit status **${status.state}** on \`${ref.slice(0, 7)}\` in **${owner}/${repo}** (context: ${status.context}).`
-    };
-  })
-  .build();

package/src/tools/create-release.ts

@@ -1,69 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let createRelease = SlateTool.create(spec, {
-  name: 'Create Release',
-  key: 'create_release',
-  description: `Create a new release for a GitHub repository with a tag, name, release notes, and draft/pre-release options.
-Can automatically generate release notes from commits since the last release.`
-})
-  .input(
-    z.object({
-      owner: z.string().describe('Repository owner'),
-      repo: z.string().describe('Repository name'),
-      tagName: z.string().describe('Tag name for the release (e.g., "v1.0.0")'),
-      targetCommitish: z
-        .string()
-        .optional()
-        .describe('Branch or commit SHA for the tag (defaults to default branch)'),
-      name: z.string().optional().describe('Release title'),
-      body: z.string().optional().describe('Release notes in Markdown'),
-      draft: z.boolean().optional().describe('Create as a draft release'),
-      prerelease: z.boolean().optional().describe('Mark as a pre-release'),
-      generateReleaseNotes: z
-        .boolean()
-        .optional()
-        .describe('Auto-generate release notes from commits')
-    })
-  )
-  .output(
-    z.object({
-      releaseId: z.number().describe('Release ID'),
-      tagName: z.string().describe('Tag name'),
-      name: z.string().nullable().describe('Release title'),
-      htmlUrl: z.string().describe('URL to the release on GitHub'),
-      draft: z.boolean().describe('Whether this is a draft'),
-      prerelease: z.boolean().describe('Whether this is a pre-release'),
-      createdAt: z.string().describe('Creation timestamp'),
-      publishedAt: z.string().nullable().describe('Publication timestamp')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let release = await client.createRelease(ctx.input.owner, ctx.input.repo, {
-      tagName: ctx.input.tagName,
-      targetCommitish: ctx.input.targetCommitish,
-      name: ctx.input.name,
-      body: ctx.input.body,
-      draft: ctx.input.draft,
-      prerelease: ctx.input.prerelease,
-      generateReleaseNotes: ctx.input.generateReleaseNotes
-    });
-
-    return {
-      output: {
-        releaseId: release.id,
-        tagName: release.tag_name,
-        name: release.name,
-        htmlUrl: release.html_url,
-        draft: release.draft,
-        prerelease: release.prerelease,
-        createdAt: release.created_at,
-        publishedAt: release.published_at
-      },
-      message: `Created release **${release.tag_name}**${release.name ? ` "${release.name}"` : ''} in **${ctx.input.owner}/${ctx.input.repo}** — ${release.html_url}`
-    };
-  })
-  .build();

package/src/tools/create-repository.ts

@@ -1,70 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let createRepository = SlateTool.create(spec, {
-  name: 'Create Repository',
-  key: 'create_repository',
-  description: `Create a new GitHub repository for the authenticated user or within an organization.
-Supports initializing with a README, gitignore template, and license.`,
-  tags: {
-    destructive: false
-  }
-})
-  .input(
-    z.object({
-      name: z.string().describe('Repository name'),
-      description: z.string().optional().describe('Repository description'),
-      private: z
-        .boolean()
-        .optional()
-        .describe('Whether the repository should be private (default: false)'),
-      autoInit: z.boolean().optional().describe('Initialize with a README'),
-      gitignoreTemplate: z
-        .string()
-        .optional()
-        .describe('Gitignore template name (e.g., "Node", "Python")'),
-      licenseTemplate: z
-        .string()
-        .optional()
-        .describe('License template (e.g., "mit", "apache-2.0")'),
-      org: z
-        .string()
-        .optional()
-        .describe(
-          'Organization to create the repository in. If omitted, creates under the authenticated user.'
-        )
-    })
-  )
-  .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'),
-      cloneUrl: z.string().describe('HTTPS clone URL'),
-      sshUrl: z.string().describe('SSH clone URL'),
-      private: z.boolean().describe('Whether the repository is private'),
-      defaultBranch: z.string().describe('Default branch name')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let repo = await client.createRepository(ctx.input);
-
-    return {
-      output: {
-        repositoryId: repo.id,
-        name: repo.name,
-        fullName: repo.full_name,
-        htmlUrl: repo.html_url,
-        cloneUrl: repo.clone_url,
-        sshUrl: repo.ssh_url,
-        private: repo.private,
-        defaultBranch: repo.default_branch
-      },
-      message: `Created ${repo.private ? 'private' : 'public'} repository **${repo.full_name}** — ${repo.html_url}`
-    };
-  })
-  .build();

package/src/tools/get-issue.ts

@@ -1,67 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let getIssue = SlateTool.create(spec, {
-  name: 'Get Issue',
-  key: 'get_issue',
-  description: `Retrieve detailed information about a specific issue, including its body, comments count, labels, assignees, and milestone.`,
-  tags: {
-    readOnly: true
-  }
-})
-  .input(
-    z.object({
-      owner: z.string().describe('Repository owner (user or organization)'),
-      repo: z.string().describe('Repository name'),
-      issueNumber: z.number().describe('Issue number')
-    })
-  )
-  .output(
-    z.object({
-      issueNumber: z.number().describe('Issue number'),
-      issueId: z.number().describe('Unique issue ID'),
-      title: z.string().describe('Issue title'),
-      body: z.string().nullable().describe('Issue body in Markdown'),
-      state: z.string().describe('Issue state (open/closed)'),
-      stateReason: z.string().nullable().describe('Reason for the state'),
-      htmlUrl: z.string().describe('URL to the issue on GitHub'),
-      author: z.string().describe('Issue author login'),
-      assignees: z.array(z.string()).describe('Assigned usernames'),
-      labels: z.array(z.string()).describe('Label names'),
-      milestoneName: z.string().nullable().describe('Milestone title'),
-      commentsCount: z.number().describe('Number of comments'),
-      locked: z.boolean().describe('Whether the issue is locked'),
-      createdAt: z.string().describe('Creation timestamp'),
-      updatedAt: z.string().describe('Last update timestamp'),
-      closedAt: z.string().nullable().describe('Closure timestamp')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let issue = await client.getIssue(ctx.input.owner, ctx.input.repo, ctx.input.issueNumber);
-
-    return {
-      output: {
-        issueNumber: issue.number,
-        issueId: issue.id,
-        title: issue.title,
-        body: issue.body,
-        state: issue.state,
-        stateReason: issue.state_reason ?? null,
-        htmlUrl: issue.html_url,
-        author: issue.user.login,
-        assignees: (issue.assignees ?? []).map((a: any) => a.login),
-        labels: (issue.labels ?? []).map((l: any) => l.name),
-        milestoneName: issue.milestone?.title ?? null,
-        commentsCount: issue.comments,
-        locked: issue.locked,
-        createdAt: issue.created_at,
-        updatedAt: issue.updated_at,
-        closedAt: issue.closed_at
-      },
-      message: `Issue **#${issue.number}**: "${issue.title}" (${issue.state}) — ${issue.html_url}`
-    };
-  })
-  .build();

package/src/tools/get-repository.ts

@@ -1,75 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let getRepository = SlateTool.create(spec, {
-  name: 'Get Repository',
-  key: 'get_repository',
-  description: `Retrieve detailed information about a GitHub repository including its settings, statistics, and metadata.
-Use this to inspect a repository's configuration, check its visibility, default branch, language, star/fork counts, and more.`,
-  tags: {
-    readOnly: true
-  }
-})
-  .input(
-    z.object({
-      owner: z.string().describe('Repository owner (user or organization)'),
-      repo: z.string().describe('Repository name')
-    })
-  )
-  .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'),
-      owner: z.string().describe('Repository owner login'),
-      private: z.boolean().describe('Whether the repository is private'),
-      description: z.string().nullable().describe('Repository description'),
-      htmlUrl: z.string().describe('URL to the repository on GitHub'),
-      defaultBranch: z.string().describe('Default branch name'),
-      language: z.string().nullable().describe('Primary programming language'),
-      stargazersCount: z.number().describe('Number of stars'),
-      forksCount: z.number().describe('Number of forks'),
-      openIssuesCount: z.number().describe('Number of open issues'),
-      archived: z.boolean().describe('Whether the repository is archived'),
-      createdAt: z.string().describe('Creation timestamp'),
-      updatedAt: z.string().describe('Last update timestamp'),
-      pushedAt: z.string().nullable().describe('Last push timestamp'),
-      topics: z.array(z.string()).describe('Repository topics'),
-      hasIssues: z.boolean().describe('Whether issues are enabled'),
-      hasWiki: z.boolean().describe('Whether wiki is enabled'),
-      hasProjects: z.boolean().describe('Whether projects are enabled')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let repo = await client.getRepository(ctx.input.owner, ctx.input.repo);
-
-    return {
-      output: {
-        repositoryId: repo.id,
-        name: repo.name,
-        fullName: repo.full_name,
-        owner: repo.owner.login,
-        private: repo.private,
-        description: repo.description,
-        htmlUrl: repo.html_url,
-        defaultBranch: repo.default_branch,
-        language: repo.language,
-        stargazersCount: repo.stargazers_count,
-        forksCount: repo.forks_count,
-        openIssuesCount: repo.open_issues_count,
-        archived: repo.archived,
-        createdAt: repo.created_at,
-        updatedAt: repo.updated_at,
-        pushedAt: repo.pushed_at,
-        topics: repo.topics ?? [],
-        hasIssues: repo.has_issues,
-        hasWiki: repo.has_wiki,
-        hasProjects: repo.has_projects
-      },
-      message: `Retrieved repository **${repo.full_name}** — ${repo.private ? 'private' : 'public'}, ${repo.stargazers_count} stars, default branch \`${repo.default_branch}\`.`
-    };
-  })
-  .build();

package/src/tools/get-user.ts

@@ -1,64 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let getUser = SlateTool.create(spec, {
-  name: 'Get User',
-  key: 'get_user',
-  description: `Retrieve a GitHub user's profile. Provide a username to look up any user, or omit it to get the authenticated user's profile.`,
-  tags: {
-    readOnly: true
-  }
-})
-  .input(
-    z.object({
-      username: z
-        .string()
-        .optional()
-        .describe('GitHub username to look up. Omit to get the authenticated user.')
-    })
-  )
-  .output(
-    z.object({
-      userId: z.number().describe('User ID'),
-      login: z.string().describe('Username'),
-      name: z.string().nullable().describe('Display name'),
-      email: z.string().nullable().describe('Public email'),
-      bio: z.string().nullable().describe('User bio'),
-      company: z.string().nullable().describe('Company'),
-      location: z.string().nullable().describe('Location'),
-      htmlUrl: z.string().describe('Profile URL'),
-      avatarUrl: z.string().describe('Avatar URL'),
-      publicRepos: z.number().describe('Number of public repositories'),
-      followers: z.number().describe('Number of followers'),
-      following: z.number().describe('Number of users following'),
-      createdAt: z.string().describe('Account creation timestamp')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let user = ctx.input.username
-      ? await client.getUser(ctx.input.username)
-      : await client.getAuthenticatedUser();
-
-    return {
-      output: {
-        userId: user.id,
-        login: user.login,
-        name: user.name,
-        email: user.email,
-        bio: user.bio,
-        company: user.company,
-        location: user.location,
-        htmlUrl: user.html_url,
-        avatarUrl: user.avatar_url,
-        publicRepos: user.public_repos,
-        followers: user.followers,
-        following: user.following,
-        createdAt: user.created_at
-      },
-      message: `User **${user.login}**${user.name ? ` (${user.name})` : ''} — ${user.public_repos} public repos, ${user.followers} followers.`
-    };
-  })
-  .build();

package/src/tools/index.ts

@@ -1,24 +0,0 @@
-export * from './get-repository';
-export * from './list-repositories';
-export * from './create-repository';
-export * from './update-repository';
-export * from './star-repository';
-export * from './manage-issue';
-export * from './list-issues';
-export * from './get-issue';
-export * from './comment-on-issue';
-export * from './manage-pull-request';
-export * from './list-pull-requests';
-export * from './merge-pull-request';
-export * from './review-pull-request';
-export * from './search';
-export * from './manage-file-content';
-export * from './manage-workflow';
-export * from './create-release';
-export * from './list-commits';
-export * from './list-branches';
-export * from './manage-labels';
-export * from './manage-gist';
-export * from './manage-collaborators';
-export * from './get-user';
-export * from './create-commit-status';

package/src/tools/list-branches.ts

@@ -1,54 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let listBranches = SlateTool.create(spec, {
-  name: 'List Branches',
-  key: 'list_branches',
-  description: `List branches in a GitHub repository with optional filtering for protected branches.`,
-  tags: {
-    readOnly: true
-  }
-})
-  .input(
-    z.object({
-      owner: z.string().describe('Repository owner'),
-      repo: z.string().describe('Repository name'),
-      protected: z.boolean().optional().describe('Filter by protection status'),
-      perPage: z.number().optional().describe('Results per page (max 100)'),
-      page: z.number().optional().describe('Page number')
-    })
-  )
-  .output(
-    z.object({
-      branches: z.array(
-        z.object({
-          name: z.string().describe('Branch name'),
-          sha: z.string().describe('HEAD commit SHA'),
-          protected: z.boolean().describe('Whether the branch is protected')
-        })
-      ),
-      totalCount: z.number().describe('Number of branches returned')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let branches = await client.listBranches(ctx.input.owner, ctx.input.repo, {
-      perPage: ctx.input.perPage,
-      page: ctx.input.page,
-      protected: ctx.input.protected
-    });
-
-    let mapped = branches.map((b: any) => ({
-      name: b.name,
-      sha: b.commit.sha,
-      protected: b.protected
-    }));
-
-    return {
-      output: { branches: mapped, totalCount: mapped.length },
-      message: `Found **${mapped.length}** branches in **${ctx.input.owner}/${ctx.input.repo}**.`
-    };
-  })
-  .build();

package/src/tools/list-commits.ts

@@ -1,70 +0,0 @@
-import { SlateTool } from 'slates';
-import { GitHubClient } from '../lib/client';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-export let listCommits = SlateTool.create(spec, {
-  name: 'List Commits',
-  key: 'list_commits',
-  description: `List commits on a repository branch with filtering by SHA, path, author, or date range.`,
-  tags: {
-    readOnly: true
-  }
-})
-  .input(
-    z.object({
-      owner: z.string().describe('Repository owner'),
-      repo: z.string().describe('Repository name'),
-      sha: z.string().optional().describe('Branch name or commit SHA to start listing from'),
-      path: z.string().optional().describe('Only commits containing this file path'),
-      author: z.string().optional().describe('GitHub login or email to filter by'),
-      since: z.string().optional().describe('Only commits after this ISO 8601 date'),
-      until: z.string().optional().describe('Only commits before this ISO 8601 date'),
-      perPage: z.number().optional().describe('Results per page (max 100)'),
-      page: z.number().optional().describe('Page number')
-    })
-  )
-  .output(
-    z.object({
-      commits: z.array(
-        z.object({
-          sha: z.string().describe('Commit SHA'),
-          message: z.string().describe('Commit message'),
-          author: z.string().nullable().describe('Author login'),
-          authorEmail: z.string().nullable().describe('Author email'),
-          committerLogin: z.string().nullable().describe('Committer login'),
-          date: z.string().describe('Commit date'),
-          htmlUrl: z.string().describe('URL to the commit on GitHub')
-        })
-      ),
-      totalCount: z.number().describe('Number of commits returned')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = new GitHubClient({ token: ctx.auth.token, instanceUrl: ctx.auth.instanceUrl });
-    let commits = await client.listCommits(ctx.input.owner, ctx.input.repo, {
-      sha: ctx.input.sha,
-      path: ctx.input.path,
-      author: ctx.input.author,
-      since: ctx.input.since,
-      until: ctx.input.until,
-      perPage: ctx.input.perPage,
-      page: ctx.input.page
-    });
-
-    let mapped = commits.map((c: any) => ({
-      sha: c.sha,
-      message: c.commit.message,
-      author: c.author?.login ?? null,
-      authorEmail: c.commit.author?.email ?? null,
-      committerLogin: c.committer?.login ?? null,
-      date: c.commit.author?.date ?? c.commit.committer?.date,
-      htmlUrl: c.html_url
-    }));
-
-    return {
-      output: { commits: mapped, totalCount: mapped.length },
-      message: `Found **${mapped.length}** commits in **${ctx.input.owner}/${ctx.input.repo}**${ctx.input.sha ? ` on \`${ctx.input.sha}\`` : ''}.`
-    };
-  })
-  .build();