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

package/dist/tools/categories/users.js

@@ -1,247 +1,474 @@
-export const usersTools = [
-    {
-        name: 'github_users_getAuthenticated',
-        description: 'Get the authenticated user',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'github_users_get',
-        description: 'Get a user by username',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'GitHub username' },
-            },
-            required: ['username'],
-        },
-    },
-    {
-        name: 'github_users_updateAuthenticated',
-        description: 'Update the authenticated user profile',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Display name' },
-                email: { type: 'string', description: 'Public email' },
-                blog: { type: 'string', description: 'Blog URL' },
-                twitter_username: { type: 'string', description: 'Twitter username' },
-                company: { type: 'string', description: 'Company name' },
-                location: { type: 'string', description: 'Location' },
-                hireable: { type: 'boolean', description: 'Available for hire' },
-                bio: { type: 'string', description: 'Bio text' },
-            },
-        },
-    },
-    {
-        name: 'github_users_listFollowers',
-        description: 'List followers of a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'GitHub username (omit for authenticated user)' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-        },
-    },
-    {
-        name: 'github_users_listFollowing',
-        description: 'List users that a user is following',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'GitHub username (omit for authenticated user)' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-        },
-    },
-    {
-        name: 'github_users_checkFollowing',
-        description: 'Check if a user follows another user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'User to check' },
-                target_user: { type: 'string', description: 'Target user to check if followed' },
-            },
-            required: ['username', 'target_user'],
-        },
-    },
-    {
-        name: 'github_users_follow',
-        description: 'Follow a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'User to follow' },
-            },
-            required: ['username'],
-        },
-    },
-    {
-        name: 'github_users_unfollow',
-        description: 'Unfollow a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'User to unfollow' },
-            },
-            required: ['username'],
-        },
-    },
-    {
-        name: 'github_users_listEmails',
-        description: 'List email addresses for the authenticated user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-        },
-    },
-    {
-        name: 'github_users_addEmails',
-        description: 'Add email addresses for the authenticated user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                emails: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Email addresses to add',
-                },
-            },
-            required: ['emails'],
-        },
-    },
-    {
-        name: 'github_users_listPublicKeys',
-        description: 'List public SSH keys for a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'GitHub username (omit for authenticated user)' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-        },
-    },
-    {
-        name: 'github_users_createPublicKey',
-        description: 'Create a public SSH key for the authenticated user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                title: { type: 'string', description: 'Key title' },
-                key: { type: 'string', description: 'Public key content' },
-            },
-            required: ['title', 'key'],
-        },
-    },
-    {
-        name: 'github_users_listGpgKeys',
-        description: 'List GPG keys for a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'GitHub username (omit for authenticated user)' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-        },
-    },
-    {
-        name: 'github_users_listBlocked',
-        description: 'List users blocked by the authenticated user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-        },
-    },
-    {
-        name: 'github_users_block',
-        description: 'Block a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'User to block' },
-            },
-            required: ['username'],
-        },
-    },
-    {
-        name: 'github_users_unblock',
-        description: 'Unblock a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'User to unblock' },
-            },
-            required: ['username'],
-        },
-    },
-];
-export async function handleUsersTool(octokit, args) {
-    const username = args.username;
-    // Get authenticated user
-    if (Object.keys(args).length === 0) {
-        const { data } = await octokit.users.getAuthenticated();
-        return data;
-    }
-    // Get user by username (simple get)
-    if (username && Object.keys(args).filter(k => k !== 'username').length === 0) {
-        const { data } = await octokit.users.getByUsername({ username });
-        return data;
-    }
-    // Update authenticated user
-    if ('name' in args || 'email' in args || 'blog' in args || 'bio' in args || 'company' in args || 'location' in args || 'hireable' in args || 'twitter_username' in args) {
-        const { data } = await octokit.users.updateAuthenticated(args);
-        return data;
-    }
-    // List followers
-    if ('per_page' in args || 'page' in args) {
-        if (username) {
-            const { data } = await octokit.users.listFollowersForUser({ username, ...args });
-            return data;
-        }
-        const { data } = await octokit.users.listFollowersForAuthenticatedUser(args);
-        return data;
-    }
-    // Check following
-    if ('target_user' in args && username) {
-        try {
-            await octokit.users.checkFollowingForUser({ username, target_user: args.target_user });
-            return { following: true };
-        }
-        catch {
-            return { following: false };
-        }
-    }
-    // Follow user
-    if (username && !('target_user' in args) && !('emails' in args) && !('key' in args)) {
-        await octokit.users.follow({ username });
-        return { success: true, message: `Now following ${username}` };
-    }
-    // List emails
-    if ('emails' in args && Array.isArray(args.emails)) {
-        const { data } = await octokit.users.addEmailForAuthenticatedUser({ emails: args.emails });
-        return data;
-    }
-    // Create public key
-    if ('title' in args && 'key' in args) {
-        const { data } = await octokit.users.createPublicSshKeyForAuthenticatedUser(args);
-        return data;
-    }
-    // Default: get authenticated user
-    const { data } = await octokit.users.getAuthenticated();
-    return data;
-}
-//# sourceMappingURL=users.js.map
+import { successResult } from '../types.js';
+export const usersCategory = {
+    name: 'users',
+    description: 'User management tools',
+    tools: [
+        // get_authenticated - Get the authenticated user
+        {
+            definition: {
+                name: 'github_users_get_authenticated',
+                description: 'Get the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            handler: async (octokit) => {
+                const { data } = await octokit.users.getAuthenticated();
+                return successResult(data);
+            },
+        },
+        // get_by_username - Get a user by username
+        {
+            definition: {
+                name: 'github_users_get_by_username',
+                description: 'Get a user by username',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.users.getByUsername({
+                    username: args.username,
+                });
+                return successResult(data);
+            },
+        },
+        // update_authenticated - Update the authenticated user
+        {
+            definition: {
+                name: 'github_users_update_authenticated',
+                description: 'Update the authenticated user profile',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Display name',
+                        },
+                        email: {
+                            type: 'string',
+                            description: 'Public email address',
+                        },
+                        blog: {
+                            type: 'string',
+                            description: 'Blog URL',
+                        },
+                        twitter_username: {
+                            type: 'string',
+                            description: 'Twitter username',
+                        },
+                        company: {
+                            type: 'string',
+                            description: 'Company name',
+                        },
+                        location: {
+                            type: 'string',
+                            description: 'Location',
+                        },
+                        hireable: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Available for hire',
+                        },
+                        bio: {
+                            type: 'string',
+                            description: 'Short biography',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.users.updateAuthenticated({
+                    name: args.name,
+                    email: args.email,
+                    blog: args.blog,
+                    twitter_username: args.twitter_username,
+                    company: args.company,
+                    location: args.location,
+                    hireable: args.hireable !== undefined ? args.hireable === 'true' : undefined,
+                    bio: args.bio,
+                });
+                return successResult(data);
+            },
+        },
+        // list - List users
+        {
+            definition: {
+                name: 'github_users_list',
+                description: 'List all users (paginated)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        since: {
+                            type: 'number',
+                            description: 'User ID to start after',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.users.list({
+                    since: args.since,
+                    per_page: args.per_page,
+                });
+                return successResult(data);
+            },
+        },
+        // list_followers - List followers
+        {
+            definition: {
+                name: 'github_users_list_followers',
+                description: 'List followers of a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username (omit for authenticated user)',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                if (args.username) {
+                    const { data } = await octokit.users.listFollowersForUser({
+                        username: args.username,
+                        per_page: args.per_page,
+                        page: args.page,
+                    });
+                    return successResult(data);
+                }
+                else {
+                    const { data } = await octokit.users.listFollowersForAuthenticatedUser({
+                        per_page: args.per_page,
+                        page: args.page,
+                    });
+                    return successResult(data);
+                }
+            },
+        },
+        // list_following - List users the user is following
+        {
+            definition: {
+                name: 'github_users_list_following',
+                description: 'List users that a user is following',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username (omit for authenticated user)',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                if (args.username) {
+                    const { data } = await octokit.users.listFollowingForUser({
+                        username: args.username,
+                        per_page: args.per_page,
+                        page: args.page,
+                    });
+                    return successResult(data);
+                }
+                else {
+                    const { data } = await octokit.users.listFollowedByAuthenticatedUser({
+                        per_page: args.per_page,
+                        page: args.page,
+                    });
+                    return successResult(data);
+                }
+            },
+        },
+        // check_following - Check if the authenticated user follows another user
+        {
+            definition: {
+                name: 'github_users_check_following',
+                description: 'Check if the authenticated user follows another user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username to check',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                try {
+                    await octokit.users.checkPersonIsFollowedByAuthenticated({
+                        username: args.username,
+                    });
+                    return successResult({ following: true });
+                }
+                catch (error) {
+                    if (error.status === 404) {
+                        return successResult({ following: false });
+                    }
+                    throw error;
+                }
+            },
+        },
+        // follow - Follow a user
+        {
+            definition: {
+                name: 'github_users_follow',
+                description: 'Follow a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username to follow',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.users.follow({
+                    username: args.username,
+                });
+                return successResult({ success: true, message: `Now following ${args.username}` });
+            },
+        },
+        // unfollow - Unfollow a user
+        {
+            definition: {
+                name: 'github_users_unfollow',
+                description: 'Unfollow a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username to unfollow',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.users.unfollow({
+                    username: args.username,
+                });
+                return successResult({ success: true, message: `Unfollowed ${args.username}` });
+            },
+        },
+        // list_blocked - List blocked users
+        {
+            definition: {
+                name: 'github_users_list_blocked',
+                description: 'List users blocked by the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.users.listBlockedByAuthenticatedUser({
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // block - Block a user
+        {
+            definition: {
+                name: 'github_users_block',
+                description: 'Block a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username to block',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.users.block({
+                    username: args.username,
+                });
+                return successResult({ success: true, message: `Blocked ${args.username}` });
+            },
+        },
+        // unblock - Unblock a user
+        {
+            definition: {
+                name: 'github_users_unblock',
+                description: 'Unblock a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username to unblock',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.users.unblock({
+                    username: args.username,
+                });
+                return successResult({ success: true, message: `Unblocked ${args.username}` });
+            },
+        },
+        // list_emails - List email addresses
+        {
+            definition: {
+                name: 'github_users_list_emails',
+                description: 'List email addresses for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.users.listEmailsForAuthenticatedUser({
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // add_email - Add email addresses
+        {
+            definition: {
+                name: 'github_users_add_email',
+                description: 'Add email addresses to the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        emails: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Email addresses to add',
+                        },
+                    },
+                    required: ['emails'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.users.addEmailForAuthenticatedUser({
+                    emails: args.emails,
+                });
+                return successResult(data);
+            },
+        },
+        // list_ssh_keys - List SSH signing keys
+        {
+            definition: {
+                name: 'github_users_list_ssh_keys',
+                description: 'List SSH signing keys for the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.users.listSshSigningKeysForAuthenticatedUser({
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
+        },
+        // get_context - Get contextual information about a user
+        {
+            definition: {
+                name: 'github_users_get_context',
+                description: 'Get contextual information about a user (hovercard)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                        subject_type: {
+                            type: 'string',
+                            enum: ['organization', 'repository', 'issue', 'pull_request'],
+                            description: 'Context type for the hovercard',
+                        },
+                        subject_id: {
+                            type: 'string',
+                            description: 'ID of the subject (required if subject_type is set)',
+                        },
+                    },
+                    required: ['username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.users.getContextForUser({
+                    username: args.username,
+                    subject_type: args.subject_type,
+                    subject_id: args.subject_id,
+                });
+                return successResult(data);
+            },
+        },
+    ],
+};