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

package/dist/tools/categories/gists.js

@@ -1,315 +1,504 @@
-export const gistsTools = [
-    {
-        name: 'github_gists_list',
-        description: 'List gists for the authenticated user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                since: { type: 'string', description: 'ISO 8601 date - only gists updated after this' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
+import { successResult } from '../types.js';
+export const gistsCategory = {
+    name: 'gists',
+    description: 'GitHub gist tools',
+    tools: [
+        // list - List gists for authenticated user
+        {
+            definition: {
+                name: 'github_gists_list',
+                description: 'List gists for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        since: {
+                            type: 'string',
+                            description: 'Only show gists updated after this time (ISO 8601 format)',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.list({
+                    since: args.since,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
             },
         },
-    },
-    {
-        name: 'github_gists_listForUser',
-        description: 'List public gists for a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'GitHub username' },
-                since: { type: 'string', description: 'ISO 8601 date' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-            required: ['username'],
+        // list_public - List public gists
+        {
+            definition: {
+                name: 'github_gists_list_public',
+                description: 'List all public gists',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        since: {
+                            type: 'string',
+                            description: 'Only show gists updated after this time (ISO 8601 format)',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.listPublic({
+                    since: args.since,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_listPublic',
-        description: 'List public gists',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                since: { type: 'string', description: 'ISO 8601 date' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
+        // list_starred - List starred gists
+        {
+            definition: {
+                name: 'github_gists_list_starred',
+                description: 'List starred gists for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        since: {
+                            type: 'string',
+                            description: 'Only show gists updated after this time (ISO 8601 format)',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.listStarred({
+                    since: args.since,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
             },
         },
-    },
-    {
-        name: 'github_gists_listStarred',
-        description: 'List starred gists for the authenticated user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                since: { type: 'string', description: 'ISO 8601 date' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
+        // list_for_user - List gists for a user
+        {
+            definition: {
+                name: 'github_gists_list_for_user',
+                description: 'List public gists for a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                        since: {
+                            type: 'string',
+                            description: 'Only show gists updated after this time (ISO 8601 format)',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.listForUser({
+                    username: args.username,
+                    since: args.since,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
             },
         },
-    },
-    {
-        name: 'github_gists_get',
-        description: 'Get a specific gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-            },
-            required: ['gist_id'],
+        // get - Get a gist
+        {
+            definition: {
+                name: 'github_gists_get',
+                description: 'Get a gist by ID',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                    },
+                    required: ['gist_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.get({
+                    gist_id: args.gist_id,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_create',
-        description: 'Create a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                description: { type: 'string', description: 'Gist description' },
-                files: {
+        // create - Create a gist
+        {
+            definition: {
+                name: 'github_gists_create',
+                description: 'Create a new gist',
+                inputSchema: {
                     type: 'object',
-                    description: 'Files in the gist. Keys are filenames, values are objects with content property',
-                    additionalProperties: {
-                        type: 'object',
-                        properties: {
-                            content: { type: 'string', description: 'File content' },
+                    properties: {
+                        description: {
+                            type: 'string',
+                            description: 'Description of the gist',
+                        },
+                        files: {
+                            type: 'object',
+                            description: 'Files to include in the gist (object with filename keys and {content} values)',
+                        },
+                        public: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Whether the gist is public',
                         },
-                        required: ['content'],
                     },
+                    required: ['files'],
                 },
-                public: { type: 'boolean', description: 'Whether the gist is public' },
             },
-            required: ['files'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.create({
+                    description: args.description,
+                    files: args.files,
+                    public: args.public === 'true',
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_update',
-        description: 'Update a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-                description: { type: 'string', description: 'Gist description' },
-                files: {
+        // update - Update a gist
+        {
+            definition: {
+                name: 'github_gists_update',
+                description: 'Update a gist',
+                inputSchema: {
                     type: 'object',
-                    description: 'Files to update. Set content to empty string to delete, or provide new content',
-                    additionalProperties: {
-                        type: 'object',
-                        properties: {
-                            content: { type: 'string', description: 'File content' },
-                            filename: { type: 'string', description: 'New filename to rename to' },
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Description of the gist',
+                        },
+                        files: {
+                            type: 'object',
+                            description: 'Files to update (set content to null to delete a file)',
                         },
                     },
+                    required: ['gist_id'],
                 },
             },
-            required: ['gist_id'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.update({
+                    gist_id: args.gist_id,
+                    description: args.description,
+                    files: args.files,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_delete',
-        description: 'Delete a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-            },
-            required: ['gist_id'],
+        // delete - Delete a gist
+        {
+            definition: {
+                name: 'github_gists_delete',
+                description: 'Delete a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                    },
+                    required: ['gist_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.gists.delete({
+                    gist_id: args.gist_id,
+                });
+                return successResult({ success: true, message: 'Gist deleted' });
+            },
         },
-    },
-    {
-        name: 'github_gists_star',
-        description: 'Star a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-            },
-            required: ['gist_id'],
+        // fork - Fork a gist
+        {
+            definition: {
+                name: 'github_gists_fork',
+                description: 'Fork a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                    },
+                    required: ['gist_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.fork({
+                    gist_id: args.gist_id,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_unstar',
-        description: 'Unstar a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-            },
-            required: ['gist_id'],
+        // star - Star a gist
+        {
+            definition: {
+                name: 'github_gists_star',
+                description: 'Star a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                    },
+                    required: ['gist_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.gists.star({
+                    gist_id: args.gist_id,
+                });
+                return successResult({ success: true, message: 'Gist starred' });
+            },
         },
-    },
-    {
-        name: 'github_gists_checkIsStarred',
-        description: 'Check if a gist is starred',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-            },
-            required: ['gist_id'],
+        // unstar - Unstar a gist
+        {
+            definition: {
+                name: 'github_gists_unstar',
+                description: 'Unstar a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                    },
+                    required: ['gist_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.gists.unstar({
+                    gist_id: args.gist_id,
+                });
+                return successResult({ success: true, message: 'Gist unstarred' });
+            },
         },
-    },
-    {
-        name: 'github_gists_fork',
-        description: 'Fork a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-            },
-            required: ['gist_id'],
+        // check_is_starred - Check if a gist is starred
+        {
+            definition: {
+                name: 'github_gists_check_is_starred',
+                description: 'Check if a gist is starred by the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                    },
+                    required: ['gist_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                try {
+                    await octokit.gists.checkIsStarred({
+                        gist_id: args.gist_id,
+                    });
+                    return successResult({ starred: true });
+                }
+                catch (error) {
+                    if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+                        return successResult({ starred: false });
+                    }
+                    throw error;
+                }
+            },
         },
-    },
-    {
-        name: 'github_gists_listForks',
-        description: 'List forks of a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-            required: ['gist_id'],
+        // list_comments - List comments on a gist
+        {
+            definition: {
+                name: 'github_gists_list_comments',
+                description: 'List comments on a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['gist_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.listComments({
+                    gist_id: args.gist_id,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_listComments',
-        description: 'List comments on a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-            required: ['gist_id'],
+        // get_comment - Get a comment on a gist
+        {
+            definition: {
+                name: 'github_gists_get_comment',
+                description: 'Get a comment on a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                        comment_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the comment',
+                        },
+                    },
+                    required: ['gist_id', 'comment_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.getComment({
+                    gist_id: args.gist_id,
+                    comment_id: args.comment_id,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_createComment',
-        description: 'Create a comment on a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-                body: { type: 'string', description: 'Comment body' },
-            },
-            required: ['gist_id', 'body'],
+        // create_comment - Create a comment on a gist
+        {
+            definition: {
+                name: 'github_gists_create_comment',
+                description: 'Create a comment on a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                        body: {
+                            type: 'string',
+                            description: 'The comment text',
+                        },
+                    },
+                    required: ['gist_id', 'body'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.createComment({
+                    gist_id: args.gist_id,
+                    body: args.body,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_getRevision',
-        description: 'Get a specific revision of a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-                sha: { type: 'string', description: 'Revision SHA' },
-            },
-            required: ['gist_id', 'sha'],
+        // update_comment - Update a comment on a gist
+        {
+            definition: {
+                name: 'github_gists_update_comment',
+                description: 'Update a comment on a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                        comment_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the comment',
+                        },
+                        body: {
+                            type: 'string',
+                            description: 'The updated comment text',
+                        },
+                    },
+                    required: ['gist_id', 'comment_id', 'body'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.gists.updateComment({
+                    gist_id: args.gist_id,
+                    comment_id: args.comment_id,
+                    body: args.body,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_gists_listCommits',
-        description: 'List commits for a gist',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                gist_id: { type: 'string', description: 'Gist ID' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-            required: ['gist_id'],
+        // delete_comment - Delete a comment on a gist
+        {
+            definition: {
+                name: 'github_gists_delete_comment',
+                description: 'Delete a comment on a gist',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        gist_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the gist',
+                        },
+                        comment_id: {
+                            type: 'number',
+                            description: 'The unique identifier of the comment',
+                        },
+                    },
+                    required: ['gist_id', 'comment_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.gists.deleteComment({
+                    gist_id: args.gist_id,
+                    comment_id: args.comment_id,
+                });
+                return successResult({ success: true, message: 'Comment deleted' });
+            },
         },
-    },
-];
-export async function handleGistsTool(octokit, args) {
-    const gistId = args.gist_id;
-    const username = args.username;
-    // List for authenticated user
-    if (!gistId && !username && !('public' in args) && !('starred' in args)) {
-        const { data } = await octokit.gists.list(args);
-        return data;
-    }
-    // List for user
-    if (username) {
-        const { data } = await octokit.gists.listForUser(args);
-        return data;
-    }
-    // List public
-    if ('public' in args) {
-        const { data } = await octokit.gists.listPublic(args);
-        return data;
-    }
-    // List starred
-    if ('starred' in args) {
-        const { data } = await octokit.gists.listStarred(args);
-        return data;
-    }
-    // Get gist
-    if (gistId && !('files' in args) && !('description' in args) && !('body' in args) && !('sha' in args) && Object.keys(args).filter(k => !['gist_id', 'per_page', 'page'].includes(k)).length === 0) {
-        // Could be get, listComments, listForks, listCommits
-        if ('per_page' in args || 'page' in args) {
-            const { data } = await octokit.gists.listComments(args);
-            return data;
-        }
-        const { data } = await octokit.gists.get({ gist_id: gistId });
-        return data;
-    }
-    // Create gist
-    if ('files' in args && !gistId) {
-        const { data } = await octokit.gists.create(args);
-        return data;
-    }
-    // Update gist
-    if (gistId && ('files' in args || 'description' in args)) {
-        const { data } = await octokit.gists.update(args);
-        return data;
-    }
-    // Delete gist
-    if (gistId && Object.keys(args).length === 1) {
-        await octokit.gists.delete({ gist_id: gistId });
-        return { success: true, message: 'Gist deleted' };
-    }
-    // Star gist
-    if (gistId && 'star' in args) {
-        await octokit.gists.star({ gist_id: gistId });
-        return { success: true, message: 'Gist starred' };
-    }
-    // Unstar gist
-    if (gistId && 'unstar' in args) {
-        await octokit.gists.unstar({ gist_id: gistId });
-        return { success: true, message: 'Gist unstarred' };
-    }
-    // Check if starred
-    if (gistId && 'check_starred' in args) {
-        try {
-            await octokit.gists.checkIsStarred({ gist_id: gistId });
-            return { starred: true };
-        }
-        catch {
-            return { starred: false };
-        }
-    }
-    // Fork gist
-    if (gistId && 'fork' in args) {
-        const { data } = await octokit.gists.fork({ gist_id: gistId });
-        return data;
-    }
-    // Create comment
-    if (gistId && 'body' in args) {
-        const { data } = await octokit.gists.createComment(args);
-        return data;
-    }
-    // Get revision
-    if (gistId && 'sha' in args) {
-        const { data } = await octokit.gists.getRevision(args);
-        return data;
-    }
-    // Default: list for authenticated user
-    const { data } = await octokit.gists.list();
-    return data;
-}
-//# sourceMappingURL=gists.js.map
+    ],
+};