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

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

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

package/dist/tools/categories/licenses.js

@@ -0,0 +1,95 @@
+import { successResult } from '../types.js';
+export const licensesCategory = {
+    name: 'licenses',
+    description: 'GitHub licenses tools',
+    tools: [
+        // get_all_commonly_used - List commonly used licenses
+        {
+            definition: {
+                name: 'github_licenses_get_all_commonly_used',
+                description: 'List commonly used open source licenses',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        featured: {
+                            type: 'boolean',
+                            description: 'Whether to only return featured licenses (popular ones like MIT, Apache, GPL)',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.licenses.getAllCommonlyUsed({
+                    featured: args.featured,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // get - Get a license by key
+        {
+            definition: {
+                name: 'github_licenses_get',
+                description: 'Get a license by its SPDX key (e.g., "mit", "apache-2.0", "gpl-3.0")',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        license: {
+                            type: 'string',
+                            description: 'The license SPDX identifier (e.g., "mit", "apache-2.0", "gpl-3.0")',
+                        },
+                    },
+                    required: ['license'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.licenses.get({
+                    license: args.license,
+                });
+                return successResult(data);
+            },
+        },
+        // get_for_repo - Get license info for a repository
+        {
+            definition: {
+                name: 'github_licenses_get_for_repo',
+                description: 'Get the license for a repository',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'The account owner of the repository',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'The name of the repository',
+                        },
+                        ref: {
+                            type: 'string',
+                            description: 'The Git reference (branch, tag, or commit SHA) to get the license from. Defaults to the default branch.',
+                        },
+                    },
+                    required: ['owner', 'repo'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.licenses.getForRepo({
+                    owner: args.owner,
+                    repo: args.repo,
+                    ref: args.ref,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

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

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

package/dist/tools/categories/markdown.js

@@ -0,0 +1,64 @@
+import { successResult } from '../types.js';
+export const markdownCategory = {
+    name: 'markdown',
+    description: 'GitHub markdown tools',
+    tools: [
+        // render - Render markdown
+        {
+            definition: {
+                name: 'github_markdown_render',
+                description: 'Render a markdown document. Use mode "gfm" for GitHub Flavored Markdown with repository context.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        text: {
+                            type: 'string',
+                            description: 'The markdown text to render',
+                        },
+                        mode: {
+                            type: 'string',
+                            enum: ['markdown', 'gfm'],
+                            description: 'The rendering mode. "markdown" for plain markdown, "gfm" for GitHub Flavored Markdown',
+                        },
+                        context: {
+                            type: 'string',
+                            description: 'The repository context (owner/repo) for gfm mode. Required when mode is "gfm".',
+                        },
+                    },
+                    required: ['text'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.markdown.render({
+                    text: args.text,
+                    mode: args.mode,
+                    context: args.context,
+                });
+                return successResult({ html: data });
+            },
+        },
+        // render_raw - Render raw markdown
+        {
+            definition: {
+                name: 'github_markdown_render_raw',
+                description: 'Render raw markdown text. This endpoint renders plain markdown without GitHub-specific features.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        data: {
+                            type: 'string',
+                            description: 'The raw markdown text to render',
+                        },
+                    },
+                    required: ['data'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.markdown.renderRaw({
+                    data: args.data,
+                });
+                return successResult({ html: data });
+            },
+        },
+    ],
+};

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

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

package/dist/tools/categories/meta.js

@@ -0,0 +1,74 @@
+import { successResult } from '../types.js';
+export const metaCategory = {
+    name: 'meta',
+    description: 'GitHub API metadata tools',
+    tools: [
+        // get - Get GitHub API meta information
+        {
+            definition: {
+                name: 'github_meta_get',
+                description: 'Get GitHub API meta information including IP ranges, SSH keys, and more',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            handler: async (octokit) => {
+                const { data } = await octokit.meta.get();
+                return successResult(data);
+            },
+        },
+        // get_octocat - Get the octocat ASCII art
+        {
+            definition: {
+                name: 'github_meta_get_octocat',
+                description: 'Get the octocat ASCII art with an optional custom message',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        s: {
+                            type: 'string',
+                            description: 'Custom text to include in the octocat speech bubble',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.meta.getOctocat({
+                    s: args.s,
+                });
+                return successResult(data);
+            },
+        },
+        // get_zen - Get a random GitHub zen quote
+        {
+            definition: {
+                name: 'github_meta_get_zen',
+                description: 'Get a random GitHub zen quote',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            handler: async (octokit) => {
+                const { data } = await octokit.meta.getZen();
+                return successResult(data);
+            },
+        },
+        // get_all_versions - List all API versions
+        {
+            definition: {
+                name: 'github_meta_get_all_versions',
+                description: 'List all available GitHub API versions',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            handler: async (octokit) => {
+                const { data } = await octokit.meta.getAllVersions();
+                return successResult(data);
+            },
+        },
+    ],
+};

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

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

package/dist/tools/categories/migrations.js

@@ -0,0 +1,290 @@
+import { successResult } from '../types.js';
+export const migrationsCategory = {
+    name: 'migrations',
+    description: 'GitHub migrations tools',
+    tools: [
+        // list_for_org - List organization migrations
+        {
+            definition: {
+                name: 'github_migrations_list_for_org',
+                description: 'List the most recent migrations 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',
+                        },
+                        exclude: {
+                            type: 'string',
+                            description: 'Exclude attributes from the API response (comma-separated: repositories)',
+                        },
+                    },
+                    required: ['org'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const exclude = args.exclude
+                    ? args.exclude.split(',').map((s) => s.trim())
+                    : undefined;
+                const { data } = await octokit.migrations.listForOrg({
+                    org: args.org,
+                    per_page: args.per_page,
+                    page: args.page,
+                    exclude,
+                });
+                return successResult(data);
+            },
+        },
+        // start_for_org - Start an organization migration
+        {
+            definition: {
+                name: 'github_migrations_start_for_org',
+                description: 'Start a migration for an organization. Initiates the generation of a migration archive.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        repositories: {
+                            type: 'string',
+                            description: 'Comma-separated list of repository names to include in the migration',
+                        },
+                        lock_repositories: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Lock the repositories being migrated at the start of the migration',
+                        },
+                        exclude_metadata: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Exclude metadata from the migration (excludes releases only)',
+                        },
+                        exclude_git_data: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Exclude git data from the migration',
+                        },
+                        exclude_attachments: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Exclude attachments from the migration',
+                        },
+                        exclude_releases: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Exclude releases from the migration',
+                        },
+                        exclude_owner_projects: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Exclude organization-owned projects from the migration',
+                        },
+                        org_metadata_only: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Only export organization metadata (no repository data)',
+                        },
+                        exclude: {
+                            type: 'string',
+                            description: 'Exclude attributes from the API response (comma-separated: repositories)',
+                        },
+                    },
+                    required: ['org', 'repositories'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const repositories = args.repositories.split(',').map((s) => s.trim());
+                const exclude = args.exclude
+                    ? args.exclude.split(',').map((s) => s.trim())
+                    : undefined;
+                const { data } = await octokit.migrations.startForOrg({
+                    org: args.org,
+                    repositories,
+                    lock_repositories: args.lock_repositories === 'true',
+                    exclude_metadata: args.exclude_metadata === 'true',
+                    exclude_git_data: args.exclude_git_data === 'true',
+                    exclude_attachments: args.exclude_attachments === 'true',
+                    exclude_releases: args.exclude_releases === 'true',
+                    exclude_owner_projects: args.exclude_owner_projects === 'true',
+                    org_metadata_only: args.org_metadata_only === 'true',
+                    exclude,
+                });
+                return successResult(data);
+            },
+        },
+        // get_status_for_org - Get the status of an organization migration
+        {
+            definition: {
+                name: 'github_migrations_get_status_for_org',
+                description: 'Get the status of an organization migration',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        migration_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the migration',
+                        },
+                        exclude: {
+                            type: 'string',
+                            description: 'Exclude attributes from the API response (comma-separated: repositories)',
+                        },
+                    },
+                    required: ['org', 'migration_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const exclude = args.exclude
+                    ? args.exclude.split(',').map((s) => s.trim())
+                    : undefined;
+                const { data } = await octokit.migrations.getStatusForOrg({
+                    org: args.org,
+                    migration_id: args.migration_id,
+                    exclude,
+                });
+                return successResult(data);
+            },
+        },
+        // get_archive_for_org - Download an organization migration archive
+        {
+            definition: {
+                name: 'github_migrations_get_archive_for_org',
+                description: 'Download an organization migration archive. Returns a URL to download the migration archive.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        migration_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the migration',
+                        },
+                    },
+                    required: ['org', 'migration_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { url } = await octokit.migrations.downloadArchiveForOrg({
+                    org: args.org,
+                    migration_id: args.migration_id,
+                });
+                return successResult({ archive_url: url });
+            },
+        },
+        // delete_archive_for_org - Delete an organization migration archive
+        {
+            definition: {
+                name: 'github_migrations_delete_archive_for_org',
+                description: 'Delete an organization migration archive',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        migration_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the migration',
+                        },
+                    },
+                    required: ['org', 'migration_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.migrations.deleteArchiveForOrg({
+                    org: args.org,
+                    migration_id: args.migration_id,
+                });
+                return successResult({ success: true, message: 'Migration archive deleted' });
+            },
+        },
+        // unlock_repo_for_org - Unlock a repository after migration
+        {
+            definition: {
+                name: 'github_migrations_unlock_repo_for_org',
+                description: 'Unlock a repository that was locked for migration. This will allow the repository to be modified again.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        migration_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the migration',
+                        },
+                        repo_name: {
+                            type: 'string',
+                            description: 'The name of the repository to unlock',
+                        },
+                    },
+                    required: ['org', 'migration_id', 'repo_name'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.migrations.unlockRepoForOrg({
+                    org: args.org,
+                    migration_id: args.migration_id,
+                    repo_name: args.repo_name,
+                });
+                return successResult({ success: true, message: 'Repository unlocked' });
+            },
+        },
+        // list_repos_for_org - List repositories in an organization migration
+        {
+            definition: {
+                name: 'github_migrations_list_repos_for_org',
+                description: 'List the repositories in an organization migration',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        migration_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the migration',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['org', 'migration_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.migrations.listReposForOrg({
+                    org: args.org,
+                    migration_id: args.migration_id,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

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

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