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

package/dist/tools/categories/apps.js

@@ -0,0 +1,224 @@
+import { successResult } from '../types.js';
+export const appsCategory = {
+    name: 'apps',
+    description: 'GitHub Apps tools',
+    tools: [
+        // get_authenticated - Get the authenticated app
+        {
+            definition: {
+                name: 'github_apps_get_authenticated',
+                description: 'Get the authenticated GitHub App',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            handler: async (octokit) => {
+                const { data } = await octokit.apps.getAuthenticated();
+                return successResult(data);
+            },
+        },
+        // list_installations - List installations for the authenticated app
+        {
+            definition: {
+                name: 'github_apps_list_installations',
+                description: 'List installations for the authenticated GitHub App',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                        since: {
+                            type: 'string',
+                            description: 'Only show installations updated after this time (ISO 8601 format)',
+                        },
+                        outdated: {
+                            type: 'string',
+                            description: 'Filter by whether the installation is outdated',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.apps.listInstallations({
+                    per_page: args.per_page,
+                    page: args.page,
+                    since: args.since,
+                    outdated: args.outdated,
+                });
+                return successResult(data);
+            },
+        },
+        // get_installation - Get an installation by ID
+        {
+            definition: {
+                name: 'github_apps_get_installation',
+                description: 'Get a specific installation of the authenticated GitHub App',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        installation_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the installation',
+                        },
+                    },
+                    required: ['installation_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.apps.getInstallation({
+                    installation_id: args.installation_id,
+                });
+                return successResult(data);
+            },
+        },
+        // list_installation_repos_for_authenticated_user - List repositories accessible to the user for an installation
+        {
+            definition: {
+                name: 'github_apps_list_installation_repos_for_authenticated_user',
+                description: 'List repositories that the authenticated user has access to in an installation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        installation_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the installation',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['installation_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.apps.listInstallationReposForAuthenticatedUser({
+                    installation_id: args.installation_id,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // create_installation_access_token - Create an installation access token
+        {
+            definition: {
+                name: 'github_apps_create_installation_access_token',
+                description: 'Create an installation access token for a GitHub App installation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        installation_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the installation',
+                        },
+                        repositories: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'List of repository names to scope the token to',
+                        },
+                        repository_ids: {
+                            type: 'array',
+                            items: { type: 'number' },
+                            description: 'List of repository IDs to scope the token to',
+                        },
+                    },
+                    required: ['installation_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.apps.createInstallationAccessToken({
+                    installation_id: args.installation_id,
+                    repositories: args.repositories,
+                    repository_ids: args.repository_ids,
+                });
+                return successResult(data);
+            },
+        },
+        // get_user_installation - Get a user installation for the authenticated app
+        {
+            definition: {
+                name: 'github_apps_get_user_installation',
+                description: 'Get the installation for a specific user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.apps.getUserInstallation({
+                    username: args.username,
+                });
+                return successResult(data);
+            },
+        },
+        // get_repo_installation - Get a repository installation for the authenticated app
+        {
+            definition: {
+                name: 'github_apps_get_repo_installation',
+                description: 'Get the installation for a specific repository',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                    },
+                    required: ['owner', 'repo'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.apps.getRepoInstallation({
+                    owner: args.owner,
+                    repo: args.repo,
+                });
+                return successResult(data);
+            },
+        },
+        // get_org_installation - Get an organization installation for the authenticated app
+        {
+            definition: {
+                name: 'github_apps_get_org_installation',
+                description: 'Get the installation for a specific organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                    },
+                    required: ['org'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.apps.getOrgInstallation({
+                    org: args.org,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

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

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

package/dist/tools/categories/billing.js

@@ -0,0 +1,145 @@
+import { successResult } from '../types.js';
+export const billingCategory = {
+    name: 'billing',
+    description: 'GitHub billing tools',
+    tools: [
+        // get_github_actions_billing_org - Get GitHub Actions billing for an organization
+        {
+            definition: {
+                name: 'github_billing_get_github_actions_billing_org',
+                description: 'Get the summary of the free and paid GitHub Actions minutes used for an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'The organization name',
+                        },
+                    },
+                    required: ['org'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.billing.getGithubActionsBillingOrg({
+                    org: args.org,
+                });
+                return successResult(data);
+            },
+        },
+        // get_github_actions_billing_user - Get GitHub Actions billing for a user
+        {
+            definition: {
+                name: 'github_billing_get_github_actions_billing_user',
+                description: 'Get the summary of the free and paid GitHub Actions minutes used for a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'The handle for the GitHub user account',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.billing.getGithubActionsBillingUser({
+                    username: args.username,
+                });
+                return successResult(data);
+            },
+        },
+        // get_github_packages_billing_org - Get GitHub Packages billing for an organization
+        {
+            definition: {
+                name: 'github_billing_get_github_packages_billing_org',
+                description: 'Get the free and paid storage used for GitHub Packages in gigabytes for an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'The organization name',
+                        },
+                    },
+                    required: ['org'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.billing.getGithubPackagesBillingOrg({
+                    org: args.org,
+                });
+                return successResult(data);
+            },
+        },
+        // get_github_packages_billing_user - Get GitHub Packages billing for a user
+        {
+            definition: {
+                name: 'github_billing_get_github_packages_billing_user',
+                description: 'Get the free and paid storage used for GitHub Packages in gigabytes for a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'The handle for the GitHub user account',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.billing.getGithubPackagesBillingUser({
+                    username: args.username,
+                });
+                return successResult(data);
+            },
+        },
+        // get_shared_storage_billing_org - Get shared storage billing for an organization
+        {
+            definition: {
+                name: 'github_billing_get_shared_storage_billing_org',
+                description: 'Get the estimated paid and estimated total storage used for GitHub Actions and GitHub Packages for an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'The organization name',
+                        },
+                    },
+                    required: ['org'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.billing.getSharedStorageBillingOrg({
+                    org: args.org,
+                });
+                return successResult(data);
+            },
+        },
+        // get_shared_storage_billing_user - Get shared storage billing for a user
+        {
+            definition: {
+                name: 'github_billing_get_shared_storage_billing_user',
+                description: 'Get the estimated paid and estimated total storage used for GitHub Actions and GitHub Packages for a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'The handle for the GitHub user account',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.billing.getSharedStorageBillingUser({
+                    username: args.username,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

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

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