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

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

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

package/dist/tools/categories/git.js

@@ -0,0 +1,520 @@
+import { successResult } from '../types.js';
+export const gitCategory = {
+    name: 'git',
+    description: 'Low-level Git operations',
+    tools: [
+        // get_blob - Get a blob
+        {
+            definition: {
+                name: 'github_git_get_blob',
+                description: 'Get a blob by SHA',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        file_sha: {
+                            type: 'string',
+                            description: 'SHA of the blob',
+                        },
+                    },
+                    required: ['owner', 'repo', 'file_sha'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.getBlob({
+                    owner: args.owner,
+                    repo: args.repo,
+                    file_sha: args.file_sha,
+                });
+                return successResult(data);
+            },
+        },
+        // create_blob - Create a blob
+        {
+            definition: {
+                name: 'github_git_create_blob',
+                description: 'Create a blob',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'Content of the blob',
+                        },
+                        encoding: {
+                            type: 'string',
+                            enum: ['utf-8', 'base64'],
+                            description: 'Encoding of the content (utf-8 or base64)',
+                        },
+                    },
+                    required: ['owner', 'repo', 'content'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.createBlob({
+                    owner: args.owner,
+                    repo: args.repo,
+                    content: args.content,
+                    encoding: args.encoding,
+                });
+                return successResult(data);
+            },
+        },
+        // get_commit - Get a commit
+        {
+            definition: {
+                name: 'github_git_get_commit',
+                description: 'Get a Git commit object by SHA',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        commit_sha: {
+                            type: 'string',
+                            description: 'SHA of the commit',
+                        },
+                    },
+                    required: ['owner', 'repo', 'commit_sha'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.getCommit({
+                    owner: args.owner,
+                    repo: args.repo,
+                    commit_sha: args.commit_sha,
+                });
+                return successResult(data);
+            },
+        },
+        // create_commit - Create a commit
+        {
+            definition: {
+                name: 'github_git_create_commit',
+                description: 'Create a new Git commit object',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        message: {
+                            type: 'string',
+                            description: 'Commit message',
+                        },
+                        tree: {
+                            type: 'string',
+                            description: 'SHA of the tree object this commit points to',
+                        },
+                        parents: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Array of parent commit SHAs',
+                        },
+                        author: {
+                            type: 'string',
+                            description: 'Author info as JSON: {"name": "...", "email": "...", "date": "..."}',
+                        },
+                        committer: {
+                            type: 'string',
+                            description: 'Committer info as JSON: {"name": "...", "email": "...", "date": "..."}',
+                        },
+                        signature: {
+                            type: 'string',
+                            description: 'PGP signature for the commit',
+                        },
+                    },
+                    required: ['owner', 'repo', 'message', 'tree'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const author = args.author ? JSON.parse(args.author) : undefined;
+                const committer = args.committer ? JSON.parse(args.committer) : undefined;
+                const { data } = await octokit.git.createCommit({
+                    owner: args.owner,
+                    repo: args.repo,
+                    message: args.message,
+                    tree: args.tree,
+                    parents: args.parents,
+                    author,
+                    committer,
+                    signature: args.signature,
+                });
+                return successResult(data);
+            },
+        },
+        // get_ref - Get a reference
+        {
+            definition: {
+                name: 'github_git_get_ref',
+                description: 'Get a Git reference (e.g., heads/main, tags/v1.0)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        ref: {
+                            type: 'string',
+                            description: 'Reference name (e.g., heads/main, tags/v1.0)',
+                        },
+                    },
+                    required: ['owner', 'repo', 'ref'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.getRef({
+                    owner: args.owner,
+                    repo: args.repo,
+                    ref: args.ref,
+                });
+                return successResult(data);
+            },
+        },
+        // list_matching_refs - List matching references
+        {
+            definition: {
+                name: 'github_git_list_matching_refs',
+                description: 'List references matching a prefix (e.g., heads/, tags/)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        ref: {
+                            type: 'string',
+                            description: 'Reference prefix to match (e.g., heads/, tags/)',
+                        },
+                    },
+                    required: ['owner', 'repo', 'ref'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.listMatchingRefs({
+                    owner: args.owner,
+                    repo: args.repo,
+                    ref: args.ref,
+                });
+                return successResult(data);
+            },
+        },
+        // create_ref - Create a reference
+        {
+            definition: {
+                name: 'github_git_create_ref',
+                description: 'Create a Git reference (branch or tag)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        ref: {
+                            type: 'string',
+                            description: 'Full reference name (e.g., refs/heads/new-branch)',
+                        },
+                        sha: {
+                            type: 'string',
+                            description: 'SHA to point the reference to',
+                        },
+                    },
+                    required: ['owner', 'repo', 'ref', 'sha'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.createRef({
+                    owner: args.owner,
+                    repo: args.repo,
+                    ref: args.ref,
+                    sha: args.sha,
+                });
+                return successResult(data);
+            },
+        },
+        // update_ref - Update a reference
+        {
+            definition: {
+                name: 'github_git_update_ref',
+                description: 'Update a Git reference to point to a new SHA',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        ref: {
+                            type: 'string',
+                            description: 'Reference name (e.g., heads/main, tags/v1.0)',
+                        },
+                        sha: {
+                            type: 'string',
+                            description: 'New SHA to point the reference to',
+                        },
+                        force: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Force update even if not fast-forward',
+                        },
+                    },
+                    required: ['owner', 'repo', 'ref', 'sha'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.updateRef({
+                    owner: args.owner,
+                    repo: args.repo,
+                    ref: args.ref,
+                    sha: args.sha,
+                    force: args.force === 'true',
+                });
+                return successResult(data);
+            },
+        },
+        // delete_ref - Delete a reference
+        {
+            definition: {
+                name: 'github_git_delete_ref',
+                description: 'Delete a Git reference (branch or tag)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        ref: {
+                            type: 'string',
+                            description: 'Reference name to delete (e.g., heads/branch-name, tags/v1.0)',
+                        },
+                    },
+                    required: ['owner', 'repo', 'ref'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.git.deleteRef({
+                    owner: args.owner,
+                    repo: args.repo,
+                    ref: args.ref,
+                });
+                return successResult({ success: true, message: 'Reference deleted' });
+            },
+        },
+        // get_tag - Get a tag
+        {
+            definition: {
+                name: 'github_git_get_tag',
+                description: 'Get a Git tag object by SHA',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        tag_sha: {
+                            type: 'string',
+                            description: 'SHA of the tag',
+                        },
+                    },
+                    required: ['owner', 'repo', 'tag_sha'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.getTag({
+                    owner: args.owner,
+                    repo: args.repo,
+                    tag_sha: args.tag_sha,
+                });
+                return successResult(data);
+            },
+        },
+        // create_tag - Create a tag object
+        {
+            definition: {
+                name: 'github_git_create_tag',
+                description: 'Create a Git tag object (annotated tag)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        tag: {
+                            type: 'string',
+                            description: 'Tag name',
+                        },
+                        message: {
+                            type: 'string',
+                            description: 'Tag message',
+                        },
+                        object: {
+                            type: 'string',
+                            description: 'SHA of the object to tag',
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['commit', 'tree', 'blob'],
+                            description: 'Type of object being tagged',
+                        },
+                        tagger: {
+                            type: 'string',
+                            description: 'Tagger info as JSON: {"name": "...", "email": "...", "date": "..."}',
+                        },
+                    },
+                    required: ['owner', 'repo', 'tag', 'message', 'object', 'type'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const tagger = args.tagger ? JSON.parse(args.tagger) : undefined;
+                const { data } = await octokit.git.createTag({
+                    owner: args.owner,
+                    repo: args.repo,
+                    tag: args.tag,
+                    message: args.message,
+                    object: args.object,
+                    type: args.type,
+                    tagger,
+                });
+                return successResult(data);
+            },
+        },
+        // get_tree - Get a tree
+        {
+            definition: {
+                name: 'github_git_get_tree',
+                description: 'Get a Git tree object by SHA',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        tree_sha: {
+                            type: 'string',
+                            description: 'SHA of the tree',
+                        },
+                        recursive: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Recursively retrieve tree contents',
+                        },
+                    },
+                    required: ['owner', 'repo', 'tree_sha'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.git.getTree({
+                    owner: args.owner,
+                    repo: args.repo,
+                    tree_sha: args.tree_sha,
+                    recursive: args.recursive,
+                });
+                return successResult(data);
+            },
+        },
+        // create_tree - Create a tree
+        {
+            definition: {
+                name: 'github_git_create_tree',
+                description: 'Create a Git tree object',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        owner: {
+                            type: 'string',
+                            description: 'Repository owner',
+                        },
+                        repo: {
+                            type: 'string',
+                            description: 'Repository name',
+                        },
+                        tree: {
+                            type: 'string',
+                            description: 'Tree entries as JSON array: [{"path": "...", "mode": "100644", "type": "blob", "sha": "..."}, ...]',
+                        },
+                        base_tree: {
+                            type: 'string',
+                            description: 'SHA of the base tree to build on (for incremental updates)',
+                        },
+                    },
+                    required: ['owner', 'repo', 'tree'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const tree = JSON.parse(args.tree);
+                const { data } = await octokit.git.createTree({
+                    owner: args.owner,
+                    repo: args.repo,
+                    tree,
+                    base_tree: args.base_tree,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

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

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

package/dist/tools/categories/gitignore.js

@@ -0,0 +1,45 @@
+import { successResult } from '../types.js';
+export const gitignoreCategory = {
+    name: 'gitignore',
+    description: 'GitHub gitignore templates tools',
+    tools: [
+        // get_all_templates - List all gitignore templates
+        {
+            definition: {
+                name: 'github_gitignore_get_all_templates',
+                description: 'List all available gitignore templates',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            handler: async (octokit) => {
+                const { data } = await octokit.gitignore.getAllTemplates();
+                return successResult(data);
+            },
+        },
+        // get_template - Get a specific gitignore template
+        {
+            definition: {
+                name: 'github_gitignore_get_template',
+                description: 'Get a specific gitignore template by name',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'The name of the gitignore template (e.g., "Node", "Python", "Java")',
+                        },
+                    },
+                    required: ['name'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gitignore.getTemplate({
+                    name: args.name,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};

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

@@ -0,0 +1,33 @@
+export { reposCategory } from './repos.js';
+export { issuesCategory } from './issues.js';
+export { pullsCategory } from './pulls.js';
+export { usersCategory } from './users.js';
+export { actionsCategory } from './actions.js';
+export { searchCategory } from './search.js';
+export { orgsCategory } from './orgs.js';
+export { gistsCategory } from './gists.js';
+export { checksCategory } from './checks.js';
+export { projectsCategory } from './projects.js';
+export { teamsCategory } from './teams.js';
+export { activityCategory } from './activity.js';
+export { gitCategory } from './git.js';
+export { reactionsCategory } from './reactions.js';
+export { packagesCategory } from './packages.js';
+export { dependabotCategory } from './dependabot.js';
+export { secretScanningCategory } from './secretScanning.js';
+export { codeScanningCategory } from './codeScanning.js';
+export { codeSecurityCategory } from './codeSecurity.js';
+export { securityAdvisoriesCategory } from './securityAdvisories.js';
+export { appsCategory } from './apps.js';
+export { billingCategory } from './billing.js';
+export { codespacesCategory } from './codespaces.js';
+export { copilotCategory } from './copilot.js';
+export { migrationsCategory } from './migrations.js';
+export { interactionsCategory } from './interactions.js';
+export { rateLimitCategory } from './rateLimit.js';
+export { markdownCategory } from './markdown.js';
+export { metaCategory } from './meta.js';
+export { emojisCategory } from './emojis.js';
+export { gitignoreCategory } from './gitignore.js';
+export { licensesCategory } from './licenses.js';
+export { codesOfConductCategory } from './codesOfConduct.js';

package/dist/tools/categories/index.js

@@ -0,0 +1,33 @@
+export { reposCategory } from './repos.js';
+export { issuesCategory } from './issues.js';
+export { pullsCategory } from './pulls.js';
+export { usersCategory } from './users.js';
+export { actionsCategory } from './actions.js';
+export { searchCategory } from './search.js';
+export { orgsCategory } from './orgs.js';
+export { gistsCategory } from './gists.js';
+export { checksCategory } from './checks.js';
+export { projectsCategory } from './projects.js';
+export { teamsCategory } from './teams.js';
+export { activityCategory } from './activity.js';
+export { gitCategory } from './git.js';
+export { reactionsCategory } from './reactions.js';
+export { packagesCategory } from './packages.js';
+export { dependabotCategory } from './dependabot.js';
+export { secretScanningCategory } from './secretScanning.js';
+export { codeScanningCategory } from './codeScanning.js';
+export { codeSecurityCategory } from './codeSecurity.js';
+export { securityAdvisoriesCategory } from './securityAdvisories.js';
+export { appsCategory } from './apps.js';
+export { billingCategory } from './billing.js';
+export { codespacesCategory } from './codespaces.js';
+export { copilotCategory } from './copilot.js';
+export { migrationsCategory } from './migrations.js';
+export { interactionsCategory } from './interactions.js';
+export { rateLimitCategory } from './rateLimit.js';
+export { markdownCategory } from './markdown.js';
+export { metaCategory } from './meta.js';
+export { emojisCategory } from './emojis.js';
+export { gitignoreCategory } from './gitignore.js';
+export { licensesCategory } from './licenses.js';
+export { codesOfConductCategory } from './codesOfConduct.js';

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

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