@ldraney/github-mcp 0.1.0 → 0.2.0-beta.0

package/dist/tools/categories/teams.js

@@ -0,0 +1,614 @@
+import { successResult } from '../types.js';
+export const teamsCategory = {
+    name: 'teams',
+    description: 'GitHub teams tools',
+    tools: [
+        // list - List teams in an organization
+        {
+            definition: {
+                name: 'github_teams_list',
+                description: 'List all teams in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['org'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.list({
+                    org: args.org,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // get_by_name - Get a team by name
+        {
+            definition: {
+                name: 'github_teams_get_by_name',
+                description: 'Get a team by its slug name',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug (e.g., "justice-league")',
+                        },
+                    },
+                    required: ['org', 'team_slug'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.getByName({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                });
+                return successResult(data);
+            },
+        },
+        // create - Create a team
+        {
+            definition: {
+                name: 'github_teams_create',
+                description: 'Create a new team in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'Team name',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Team description',
+                        },
+                        maintainers: {
+                            type: 'string',
+                            description: 'Comma-separated list of GitHub usernames for team maintainers',
+                        },
+                        repo_names: {
+                            type: 'string',
+                            description: 'Comma-separated list of repository names (org/repo format)',
+                        },
+                        privacy: {
+                            type: 'string',
+                            enum: ['secret', 'closed'],
+                            description: 'Team privacy level',
+                        },
+                        notification_setting: {
+                            type: 'string',
+                            enum: ['notifications_enabled', 'notifications_disabled'],
+                            description: 'Notification setting for the team',
+                        },
+                        parent_team_id: {
+                            type: 'number',
+                            description: 'ID of the parent team for nested teams',
+                        },
+                    },
+                    required: ['org', 'name'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const maintainers = args.maintainers
+                    ? args.maintainers.split(',').map((m) => m.trim())
+                    : undefined;
+                const repoNames = args.repo_names
+                    ? args.repo_names.split(',').map((r) => r.trim())
+                    : undefined;
+                const { data } = await octokit.teams.create({
+                    org: args.org,
+                    name: args.name,
+                    description: args.description,
+                    maintainers,
+                    repo_names: repoNames,
+                    privacy: args.privacy,
+                    notification_setting: args.notification_setting,
+                    parent_team_id: args.parent_team_id,
+                });
+                return successResult(data);
+            },
+        },
+        // update - Update a team
+        {
+            definition: {
+                name: 'github_teams_update',
+                description: 'Update a team in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'New team name',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Team description',
+                        },
+                        privacy: {
+                            type: 'string',
+                            enum: ['secret', 'closed'],
+                            description: 'Team privacy level',
+                        },
+                        notification_setting: {
+                            type: 'string',
+                            enum: ['notifications_enabled', 'notifications_disabled'],
+                            description: 'Notification setting for the team',
+                        },
+                        parent_team_id: {
+                            type: 'number',
+                            description: 'ID of the parent team for nested teams (use -1 to remove parent)',
+                        },
+                    },
+                    required: ['org', 'team_slug'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const parentTeamId = args.parent_team_id;
+                const { data } = await octokit.teams.updateInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    name: args.name,
+                    description: args.description,
+                    privacy: args.privacy,
+                    notification_setting: args.notification_setting,
+                    parent_team_id: parentTeamId === -1 ? null : parentTeamId,
+                });
+                return successResult(data);
+            },
+        },
+        // delete - Delete a team
+        {
+            definition: {
+                name: 'github_teams_delete',
+                description: 'Delete a team from an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                    },
+                    required: ['org', 'team_slug'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.teams.deleteInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                });
+                return successResult({ success: true, message: 'Team deleted' });
+            },
+        },
+        // list_members_in_org - List team members
+        {
+            definition: {
+                name: 'github_teams_list_members_in_org',
+                description: 'List members of a team in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        role: {
+                            type: 'string',
+                            enum: ['member', 'maintainer', 'all'],
+                            description: 'Filter by role',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['org', 'team_slug'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.listMembersInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    role: args.role,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // get_membership_for_user_in_org - Get team membership for a user
+        {
+            definition: {
+                name: 'github_teams_get_membership_for_user_in_org',
+                description: 'Get team membership for a user in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                    },
+                    required: ['org', 'team_slug', 'username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.getMembershipForUserInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    username: args.username,
+                });
+                return successResult(data);
+            },
+        },
+        // add_or_update_membership_for_user_in_org - Add or update team membership
+        {
+            definition: {
+                name: 'github_teams_add_or_update_membership_for_user_in_org',
+                description: 'Add or update team membership for a user in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                        role: {
+                            type: 'string',
+                            enum: ['member', 'maintainer'],
+                            description: 'Role for the user in the team',
+                        },
+                    },
+                    required: ['org', 'team_slug', 'username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.addOrUpdateMembershipForUserInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    username: args.username,
+                    role: args.role,
+                });
+                return successResult(data);
+            },
+        },
+        // remove_membership_for_user_in_org - Remove team membership
+        {
+            definition: {
+                name: 'github_teams_remove_membership_for_user_in_org',
+                description: 'Remove team membership for a user in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                    },
+                    required: ['org', 'team_slug', 'username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.teams.removeMembershipForUserInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    username: args.username,
+                });
+                return successResult({ success: true, message: 'User removed from team' });
+            },
+        },
+        // list_repos_in_org - List team repositories
+        {
+            definition: {
+                name: 'github_teams_list_repos_in_org',
+                description: 'List repositories for a team in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['org', 'team_slug'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.listReposInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // add_or_update_repo_permissions_in_org - Add or update team repository permissions
+        {
+            definition: {
+                name: 'github_teams_add_or_update_repo_permissions_in_org',
+                description: 'Add or update team repository permissions in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        permission: {
+                            type: 'string',
+                            enum: ['pull', 'push', 'admin', 'maintain', 'triage'],
+                            description: 'Permission level for the repository',
+                        },
+                    },
+                    required: ['org', 'team_slug', 'owner', 'repo'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.teams.addOrUpdateRepoPermissionsInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    owner: args.owner,
+                    repo: args.repo,
+                    permission: args.permission,
+                });
+                return successResult({ success: true, message: 'Repository permissions updated' });
+            },
+        },
+        // remove_repo_in_org - Remove team repository
+        {
+            definition: {
+                name: 'github_teams_remove_repo_in_org',
+                description: 'Remove a repository from a team in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                    },
+                    required: ['org', 'team_slug', 'owner', 'repo'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.teams.removeRepoInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    owner: args.owner,
+                    repo: args.repo,
+                });
+                return successResult({ success: true, message: 'Repository removed from team' });
+            },
+        },
+        // list_discussions_in_org - List team discussions
+        {
+            definition: {
+                name: 'github_teams_list_discussions_in_org',
+                description: 'List discussions for a team in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        direction: {
+                            type: 'string',
+                            enum: ['asc', 'desc'],
+                            description: 'Sort direction',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                        pinned: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Filter to only pinned discussions',
+                        },
+                    },
+                    required: ['org', 'team_slug'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.listDiscussionsInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    direction: args.direction,
+                    per_page: args.per_page,
+                    page: args.page,
+                    pinned: args.pinned,
+                });
+                return successResult(data);
+            },
+        },
+        // get_discussion_in_org - Get a team discussion
+        {
+            definition: {
+                name: 'github_teams_get_discussion_in_org',
+                description: 'Get a specific discussion for a team in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        discussion_number: {
+                            type: 'number',
+                            description: 'Discussion number',
+                        },
+                    },
+                    required: ['org', 'team_slug', 'discussion_number'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.getDiscussionInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    discussion_number: args.discussion_number,
+                });
+                return successResult(data);
+            },
+        },
+        // create_discussion_in_org - Create a team discussion
+        {
+            definition: {
+                name: 'github_teams_create_discussion_in_org',
+                description: 'Create a discussion for a team in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        team_slug: {
+                            type: 'string',
+                            description: 'Team slug',
+                        },
+                        title: {
+                            type: 'string',
+                            description: 'Discussion title',
+                        },
+                        body: {
+                            type: 'string',
+                            description: 'Discussion body (Markdown supported)',
+                        },
+                        private: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Whether the discussion is private',
+                        },
+                    },
+                    required: ['org', 'team_slug', 'title', 'body'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.teams.createDiscussionInOrg({
+                    org: args.org,
+                    team_slug: args.team_slug,
+                    title: args.title,
+                    body: args.body,
+                    private: args.private !== undefined ? args.private === 'true' : undefined,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

package/dist/tools/categories/users.d.ts

@@ -1,5 +1,2 @@
-import { Octokit } from '@octokit/rest';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare const usersTools: Tool[];
-export declare function handleUsersTool(octokit: Octokit, args: Record<string, unknown>): Promise<unknown>;
-//# sourceMappingURL=users.d.ts.map
+import type { ToolCategory } from '../types.js';
+export declare const usersCategory: ToolCategory;