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

package/dist/tools/categories/codespaces.js

@@ -0,0 +1,259 @@
+import { successResult } from '../types.js';
+export const codespacesCategory = {
+    name: 'codespaces',
+    description: 'GitHub Codespaces tools',
+    tools: [
+        // list_for_authenticated_user - List codespaces for authenticated user
+        {
+            definition: {
+                name: 'github_codespaces_list_for_authenticated_user',
+                description: 'List codespaces for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                        repository_id: {
+                            type: 'number',
+                            description: 'Filter by repository ID',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.codespaces.listForAuthenticatedUser({
+                    per_page: args.per_page,
+                    page: args.page,
+                    repository_id: args.repository_id,
+                });
+                return successResult(data);
+            },
+        },
+        // list_in_repository_for_authenticated_user - List codespaces in a repository
+        {
+            definition: {
+                name: 'github_codespaces_list_in_repository_for_authenticated_user',
+                description: 'List codespaces in a repository for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'The account owner of the repository',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'The name of the repository',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['owner', 'repo'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.codespaces.listInRepositoryForAuthenticatedUser({
+                    owner: args.owner,
+                    repo: args.repo,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // get_for_authenticated_user - Get a codespace
+        {
+            definition: {
+                name: 'github_codespaces_get_for_authenticated_user',
+                description: 'Get a codespace by name for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        codespace_name: {
+                            type: 'string',
+                            description: 'The name of the codespace',
+                        },
+                    },
+                    required: ['codespace_name'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.codespaces.getForAuthenticatedUser({
+                    codespace_name: args.codespace_name,
+                });
+                return successResult(data);
+            },
+        },
+        // create_for_authenticated_user - Create a codespace
+        {
+            definition: {
+                name: 'github_codespaces_create_for_authenticated_user',
+                description: 'Create a codespace for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repository_id: {
+                            type: 'number',
+                            description: 'Repository ID to create the codespace for',
+                        },
+                        ref: {
+                            type: 'string',
+                            description: 'Git ref (branch or commit) to create the codespace from',
+                        },
+                        location: {
+                            type: 'string',
+                            description: 'The geographic area for the codespace (e.g., EastUs, WestUs2)',
+                        },
+                        machine: {
+                            type: 'string',
+                            description: 'Machine type to use for the codespace',
+                        },
+                        devcontainer_path: {
+                            type: 'string',
+                            description: 'Path to the devcontainer.json file to use',
+                        },
+                        working_directory: {
+                            type: 'string',
+                            description: 'Working directory for the codespace',
+                        },
+                        idle_timeout_minutes: {
+                            type: 'number',
+                            description: 'Time in minutes before the codespace is stopped after being idle',
+                        },
+                        display_name: {
+                            type: 'string',
+                            description: 'Display name for the codespace',
+                        },
+                        retention_period_minutes: {
+                            type: 'number',
+                            description: 'Duration in minutes after codespace stops before automatic deletion',
+                        },
+                    },
+                    required: ['repository_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.codespaces.createForAuthenticatedUser({
+                    repository_id: args.repository_id,
+                    ref: args.ref,
+                    location: args.location,
+                    machine: args.machine,
+                    devcontainer_path: args.devcontainer_path,
+                    working_directory: args.working_directory,
+                    idle_timeout_minutes: args.idle_timeout_minutes,
+                    display_name: args.display_name,
+                    retention_period_minutes: args.retention_period_minutes,
+                });
+                return successResult(data);
+            },
+        },
+        // start_for_authenticated_user - Start a codespace
+        {
+            definition: {
+                name: 'github_codespaces_start_for_authenticated_user',
+                description: 'Start a codespace for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        codespace_name: {
+                            type: 'string',
+                            description: 'The name of the codespace',
+                        },
+                    },
+                    required: ['codespace_name'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.codespaces.startForAuthenticatedUser({
+                    codespace_name: args.codespace_name,
+                });
+                return successResult(data);
+            },
+        },
+        // stop_for_authenticated_user - Stop a codespace
+        {
+            definition: {
+                name: 'github_codespaces_stop_for_authenticated_user',
+                description: 'Stop a codespace for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        codespace_name: {
+                            type: 'string',
+                            description: 'The name of the codespace',
+                        },
+                    },
+                    required: ['codespace_name'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.codespaces.stopForAuthenticatedUser({
+                    codespace_name: args.codespace_name,
+                });
+                return successResult(data);
+            },
+        },
+        // delete_for_authenticated_user - Delete a codespace
+        {
+            definition: {
+                name: 'github_codespaces_delete_for_authenticated_user',
+                description: 'Delete a codespace for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        codespace_name: {
+                            type: 'string',
+                            description: 'The name of the codespace',
+                        },
+                    },
+                    required: ['codespace_name'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.codespaces.deleteForAuthenticatedUser({
+                    codespace_name: args.codespace_name,
+                });
+                return successResult({ success: true, message: 'Codespace deleted' });
+            },
+        },
+        // list_secrets_for_authenticated_user - List codespace secrets
+        {
+            definition: {
+                name: 'github_codespaces_list_secrets_for_authenticated_user',
+                description: 'List secrets for the authenticated user for codespaces',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.codespaces.listSecretsForAuthenticatedUser({
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

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

@@ -0,0 +1,2 @@
+import type { ToolCategory } from '../types.js';
+export declare const copilotCategory: ToolCategory;

package/dist/tools/categories/copilot.js

@@ -0,0 +1,187 @@
+import { successResult } from '../types.js';
+export const copilotCategory = {
+    name: 'copilot',
+    description: 'GitHub Copilot tools',
+    tools: [
+        // get_copilot_organization_details - Get Copilot organization details
+        {
+            definition: {
+                name: 'github_copilot_get_copilot_organization_details',
+                description: 'Get Copilot for Business or Enterprise details for an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                    },
+                    required: ['org'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.copilot.getCopilotOrganizationDetails({
+                    org: args.org,
+                });
+                return successResult(data);
+            },
+        },
+        // list_copilot_seats - List Copilot seats for an organization
+        {
+            definition: {
+                name: 'github_copilot_list_copilot_seats',
+                description: 'List all Copilot seat assignments for 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.copilot.listCopilotSeats({
+                    org: args.org,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // add_copilot_seats_for_teams - Add Copilot seats for teams
+        {
+            definition: {
+                name: 'github_copilot_add_copilot_seats_for_teams',
+                description: 'Add Copilot seat assignments for teams in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        selected_teams: {
+                            type: 'string',
+                            description: 'Comma-separated list of team slugs to add Copilot seats for',
+                        },
+                    },
+                    required: ['org', 'selected_teams'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const selectedTeams = args.selected_teams
+                    .split(',')
+                    .map((t) => t.trim());
+                const { data } = await octokit.copilot.addCopilotSeatsForTeams({
+                    org: args.org,
+                    selected_teams: selectedTeams,
+                });
+                return successResult(data);
+            },
+        },
+        // add_copilot_seats_for_users - Add Copilot seats for users
+        {
+            definition: {
+                name: 'github_copilot_add_copilot_seats_for_users',
+                description: 'Add Copilot seat assignments for users in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        selected_usernames: {
+                            type: 'string',
+                            description: 'Comma-separated list of GitHub usernames to add Copilot seats for',
+                        },
+                    },
+                    required: ['org', 'selected_usernames'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const selectedUsernames = args.selected_usernames
+                    .split(',')
+                    .map((u) => u.trim());
+                const { data } = await octokit.copilot.addCopilotSeatsForUsers({
+                    org: args.org,
+                    selected_usernames: selectedUsernames,
+                });
+                return successResult(data);
+            },
+        },
+        // cancel_copilot_seat_assignment_for_teams - Cancel Copilot seats for teams
+        {
+            definition: {
+                name: 'github_copilot_cancel_copilot_seat_assignment_for_teams',
+                description: 'Cancel Copilot seat assignments for teams in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        selected_teams: {
+                            type: 'string',
+                            description: 'Comma-separated list of team slugs to cancel Copilot seats for',
+                        },
+                    },
+                    required: ['org', 'selected_teams'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const selectedTeams = args.selected_teams
+                    .split(',')
+                    .map((t) => t.trim());
+                const { data } = await octokit.copilot.cancelCopilotSeatAssignmentForTeams({
+                    org: args.org,
+                    selected_teams: selectedTeams,
+                });
+                return successResult(data);
+            },
+        },
+        // cancel_copilot_seat_assignment_for_users - Cancel Copilot seats for users
+        {
+            definition: {
+                name: 'github_copilot_cancel_copilot_seat_assignment_for_users',
+                description: 'Cancel Copilot seat assignments for users in an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        selected_usernames: {
+                            type: 'string',
+                            description: 'Comma-separated list of GitHub usernames to cancel Copilot seats for',
+                        },
+                    },
+                    required: ['org', 'selected_usernames'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const selectedUsernames = args.selected_usernames
+                    .split(',')
+                    .map((u) => u.trim());
+                const { data } = await octokit.copilot.cancelCopilotSeatAssignmentForUsers({
+                    org: args.org,
+                    selected_usernames: selectedUsernames,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

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

@@ -0,0 +1,2 @@
+import type { ToolCategory } from '../types.js';
+export declare const dependabotCategory: ToolCategory;