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

package/dist/tools/categories/orgs.js

@@ -1,452 +1,620 @@
-export const orgsTools = [
-    {
-        name: 'github_orgs_list',
-        description: 'List organizations for the authenticated user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                per_page: { type: 'number' },
-                page: { type: 'number' },
+import { successResult } from '../types.js';
+export const orgsCategory = {
+    name: 'orgs',
+    description: 'GitHub organization tools',
+    tools: [
+        // list - List organizations for authenticated user
+        {
+            definition: {
+                name: 'github_orgs_list',
+                description: 'List organizations 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.orgs.listForAuthenticatedUser({
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
             },
         },
-    },
-    {
-        name: 'github_orgs_listForUser',
-        description: 'List organizations for a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                username: { type: 'string', description: 'GitHub username' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-            required: ['username'],
-        },
-    },
-    {
-        name: 'github_orgs_get',
-        description: 'Get an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-            },
-            required: ['org'],
-        },
-    },
-    {
-        name: 'github_orgs_update',
-        description: 'Update an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                billing_email: { type: 'string', description: 'Billing email address' },
-                company: { type: 'string', description: 'Company name' },
-                email: { type: 'string', description: 'Public email' },
-                twitter_username: { type: 'string', description: 'Twitter username' },
-                location: { type: 'string', description: 'Location' },
-                name: { type: 'string', description: 'Display name' },
-                description: { type: 'string', description: 'Organization description' },
-                default_repository_permission: {
-                    type: 'string',
-                    enum: ['read', 'write', 'admin', 'none'],
-                    description: 'Default permission for new repos',
+        // list_for_user - List organizations for a user
+        {
+            definition: {
+                name: 'github_orgs_list_for_user',
+                description: 'List public organizations for a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['username'],
                 },
-                members_can_create_repositories: { type: 'boolean' },
             },
-            required: ['org'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.listForUser({
+                    username: args.username,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_listMembers',
-        description: 'List members of an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                filter: {
-                    type: 'string',
-                    enum: ['2fa_disabled', 'all'],
-                    description: 'Filter members',
+        // get - Get an organization
+        {
+            definition: {
+                name: 'github_orgs_get',
+                description: 'Get an organization by name',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                    },
+                    required: ['org'],
                 },
-                role: {
-                    type: 'string',
-                    enum: ['all', 'admin', 'member'],
-                    description: 'Filter by role',
-                },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
             },
-            required: ['org'],
-        },
-    },
-    {
-        name: 'github_orgs_checkMembership',
-        description: 'Check if a user is a member of an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                username: { type: 'string', description: 'GitHub username' },
-            },
-            required: ['org', 'username'],
-        },
-    },
-    {
-        name: 'github_orgs_getMembership',
-        description: 'Get organization membership for a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                username: { type: 'string', description: 'GitHub username' },
-            },
-            required: ['org', 'username'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.get({
+                    org: args.org,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_setMembership',
-        description: 'Set organization membership for a user',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                username: { type: 'string', description: 'GitHub username' },
-                role: {
-                    type: 'string',
-                    enum: ['admin', 'member'],
-                    description: 'Role to assign',
+        // update - Update an organization
+        {
+            definition: {
+                name: 'github_orgs_update',
+                description: 'Update an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        billing_email: {
+                            type: 'string',
+                            description: 'Billing email address',
+                        },
+                        company: {
+                            type: 'string',
+                            description: 'Company name',
+                        },
+                        email: {
+                            type: 'string',
+                            description: 'Public email address',
+                        },
+                        location: {
+                            type: 'string',
+                            description: 'Location',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'Display name',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Organization description',
+                        },
+                        default_repository_permission: {
+                            type: 'string',
+                            enum: ['read', 'write', 'admin', 'none'],
+                            description: 'Default repository permission for members',
+                        },
+                        members_can_create_repositories: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Whether members can create repositories',
+                        },
+                    },
+                    required: ['org'],
                 },
             },
-            required: ['org', 'username', 'role'],
-        },
-    },
-    {
-        name: 'github_orgs_removeMember',
-        description: 'Remove a member from an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                username: { type: 'string', description: 'GitHub username' },
-            },
-            required: ['org', 'username'],
-        },
-    },
-    {
-        name: 'github_orgs_listTeams',
-        description: 'List teams in an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-            required: ['org'],
-        },
-    },
-    {
-        name: 'github_orgs_getTeam',
-        description: 'Get a team by slug',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                team_slug: { type: 'string', description: 'Team slug' },
-            },
-            required: ['org', 'team_slug'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.update({
+                    org: args.org,
+                    billing_email: args.billing_email,
+                    company: args.company,
+                    email: args.email,
+                    location: args.location,
+                    name: args.name,
+                    description: args.description,
+                    default_repository_permission: args.default_repository_permission,
+                    members_can_create_repositories: args.members_can_create_repositories !== undefined ? args.members_can_create_repositories === 'true' : undefined,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_createTeam',
-        description: 'Create a team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                name: { type: 'string', description: 'Team name' },
-                description: { type: 'string', description: 'Team description' },
-                maintainers: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'GitHub usernames of team maintainers',
-                },
-                repo_names: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Full repo names (org/repo) to add',
-                },
-                privacy: {
-                    type: 'string',
-                    enum: ['secret', 'closed'],
-                    description: 'Team privacy level',
+        // list_members - List organization members
+        {
+            definition: {
+                name: 'github_orgs_list_members',
+                description: 'List members of an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        filter: {
+                            type: 'string',
+                            enum: ['2fa_disabled', 'all'],
+                            description: 'Filter members by 2FA status',
+                        },
+                        role: {
+                            type: 'string',
+                            enum: ['all', 'admin', 'member'],
+                            description: 'Filter by role',
+                        },
+                        per_page: {
+                            type: 'number',
+                            description: 'Results per page (max 100)',
+                        },
+                        page: {
+                            type: 'number',
+                            description: 'Page number',
+                        },
+                    },
+                    required: ['org'],
                 },
-                permission: {
-                    type: 'string',
-                    enum: ['pull', 'push', 'admin'],
-                    description: 'Default permission for repos',
-                },
-                parent_team_id: { type: 'number', description: 'Parent team ID for nested teams' },
             },
-            required: ['org', 'name'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.listMembers({
+                    org: args.org,
+                    filter: args.filter,
+                    role: args.role,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_updateTeam',
-        description: 'Update a team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                team_slug: { type: 'string', description: 'Team slug' },
-                name: { type: 'string', description: 'Team name' },
-                description: { type: 'string', description: 'Team description' },
-                privacy: {
-                    type: 'string',
-                    enum: ['secret', 'closed'],
+        // get_membership - Get organization membership for a user
+        {
+            definition: {
+                name: 'github_orgs_get_membership',
+                description: 'Get organization membership for a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                    },
+                    required: ['org', 'username'],
                 },
-                permission: {
-                    type: 'string',
-                    enum: ['pull', 'push', 'admin'],
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.getMembershipForUser({
+                    org: args.org,
+                    username: args.username,
+                });
+                return successResult(data);
+            },
+        },
+        // set_membership - Set organization membership for a user
+        {
+            definition: {
+                name: 'github_orgs_set_membership',
+                description: 'Set organization membership for a user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                        role: {
+                            type: 'string',
+                            enum: ['admin', 'member'],
+                            description: 'Role for the user in the organization',
+                        },
+                    },
+                    required: ['org', 'username'],
                 },
-                parent_team_id: { type: 'number' },
             },
-            required: ['org', 'team_slug'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.setMembershipForUser({
+                    org: args.org,
+                    username: args.username,
+                    role: args.role,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_deleteTeam',
-        description: 'Delete a team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                team_slug: { type: 'string', description: 'Team slug' },
-            },
-            required: ['org', 'team_slug'],
+        // remove_member - Remove a member from an organization
+        {
+            definition: {
+                name: 'github_orgs_remove_member',
+                description: 'Remove a member from an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        username: {
+                            type: 'string',
+                            description: 'GitHub username',
+                        },
+                    },
+                    required: ['org', 'username'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.orgs.removeMember({
+                    org: args.org,
+                    username: args.username,
+                });
+                return successResult({ success: true, message: 'Member removed from organization' });
+            },
         },
-    },
-    {
-        name: 'github_orgs_listTeamMembers',
-        description: 'List members of a team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                team_slug: { type: 'string', description: 'Team slug' },
-                role: {
-                    type: 'string',
-                    enum: ['member', 'maintainer', 'all'],
+        // list_pending_invitations - List pending organization invitations
+        {
+            definition: {
+                name: 'github_orgs_list_pending_invitations',
+                description: 'List pending invitations 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',
+                        },
+                    },
+                    required: ['org'],
                 },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
             },
-            required: ['org', 'team_slug'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.listPendingInvitations({
+                    org: args.org,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_addTeamMember',
-        description: 'Add a member to a team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                team_slug: { type: 'string', description: 'Team slug' },
-                username: { type: 'string', description: 'GitHub username' },
-                role: {
-                    type: 'string',
-                    enum: ['member', 'maintainer'],
-                    description: 'Role in the team',
+        // create_invitation - Create an organization invitation
+        {
+            definition: {
+                name: 'github_orgs_create_invitation',
+                description: 'Create an invitation to join an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        invitee_id: {
+                            type: 'number',
+                            description: 'GitHub user ID to invite',
+                        },
+                        email: {
+                            type: 'string',
+                            description: 'Email address to invite (if not using invitee_id)',
+                        },
+                        role: {
+                            type: 'string',
+                            enum: ['admin', 'direct_member', 'billing_manager'],
+                            description: 'Role for the invited user',
+                        },
+                        team_ids: {
+                            type: 'string',
+                            description: 'Comma-separated list of team IDs to add the user to',
+                        },
+                    },
+                    required: ['org'],
                 },
             },
-            required: ['org', 'team_slug', 'username'],
+            handler: async (octokit, args) => {
+                const teamIds = args.team_ids
+                    ? args.team_ids.split(',').map((id) => parseInt(id.trim(), 10))
+                    : undefined;
+                const { data } = await octokit.orgs.createInvitation({
+                    org: args.org,
+                    invitee_id: args.invitee_id,
+                    email: args.email,
+                    role: args.role,
+                    team_ids: teamIds,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_removeTeamMember',
-        description: 'Remove a member from a team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                team_slug: { type: 'string', description: 'Team slug' },
-                username: { type: 'string', description: 'GitHub username' },
-            },
-            required: ['org', 'team_slug', 'username'],
+        // cancel_invitation - Cancel an organization invitation
+        {
+            definition: {
+                name: 'github_orgs_cancel_invitation',
+                description: 'Cancel an organization invitation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        invitation_id: {
+                            type: 'number',
+                            description: 'Invitation ID',
+                        },
+                    },
+                    required: ['org', 'invitation_id'],
+                },
+            },
+            handler: async (octokit, args) => {
+                await octokit.orgs.cancelInvitation({
+                    org: args.org,
+                    invitation_id: args.invitation_id,
+                });
+                return successResult({ success: true, message: 'Invitation cancelled' });
+            },
         },
-    },
-    {
-        name: 'github_orgs_listTeamRepos',
-        description: 'List repositories for a team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                team_slug: { type: 'string', description: 'Team slug' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-            required: ['org', 'team_slug'],
+        // list_webhooks - List organization webhooks
+        {
+            definition: {
+                name: 'github_orgs_list_webhooks',
+                description: 'List webhooks 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',
+                        },
+                    },
+                    required: ['org'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.listWebhooks({
+                    org: args.org,
+                    per_page: args.per_page,
+                    page: args.page,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_addTeamRepo',
-        description: 'Add a repository to a team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                team_slug: { type: 'string', description: 'Team slug' },
-                owner: { type: 'string', description: 'Repository owner' },
-                repo: { type: 'string', description: 'Repository name' },
-                permission: {
-                    type: 'string',
-                    enum: ['pull', 'push', 'admin', 'maintain', 'triage'],
-                    description: 'Permission level',
+        // get_webhook - Get an organization webhook
+        {
+            definition: {
+                name: 'github_orgs_get_webhook',
+                description: 'Get a webhook for an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        hook_id: {
+                            type: 'number',
+                            description: 'Webhook ID',
+                        },
+                    },
+                    required: ['org', 'hook_id'],
                 },
             },
-            required: ['org', 'team_slug', 'owner', 'repo'],
+            handler: async (octokit, args) => {
+                const { data } = await octokit.orgs.getWebhook({
+                    org: args.org,
+                    hook_id: args.hook_id,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_listInvitations',
-        description: 'List pending organization invitations',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                per_page: { type: 'number' },
-                page: { type: 'number' },
-            },
-            required: ['org'],
+        // create_webhook - Create an organization webhook
+        {
+            definition: {
+                name: 'github_orgs_create_webhook',
+                description: 'Create a webhook for an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'Webhook name (must be "web")',
+                        },
+                        config_url: {
+                            type: 'string',
+                            description: 'URL to receive webhook payloads',
+                        },
+                        config_content_type: {
+                            type: 'string',
+                            enum: ['json', 'form'],
+                            description: 'Content type for payloads',
+                        },
+                        config_secret: {
+                            type: 'string',
+                            description: 'Secret for webhook signature',
+                        },
+                        config_insecure_ssl: {
+                            type: 'string',
+                            enum: ['0', '1'],
+                            description: 'Allow insecure SSL (0 = no, 1 = yes)',
+                        },
+                        events: {
+                            type: 'string',
+                            description: 'Comma-separated list of events to subscribe to',
+                        },
+                        active: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Whether the webhook is active',
+                        },
+                    },
+                    required: ['org', 'name', 'config_url'],
+                },
+            },
+            handler: async (octokit, args) => {
+                const events = args.events
+                    ? args.events.split(',').map((e) => e.trim())
+                    : undefined;
+                const { data } = await octokit.orgs.createWebhook({
+                    org: args.org,
+                    name: args.name,
+                    config: {
+                        url: args.config_url,
+                        content_type: args.config_content_type,
+                        secret: args.config_secret,
+                        insecure_ssl: args.config_insecure_ssl,
+                    },
+                    events,
+                    active: args.active !== undefined ? args.active === 'true' : undefined,
+                });
+                return successResult(data);
+            },
         },
-    },
-    {
-        name: 'github_orgs_createInvitation',
-        description: 'Create an organization invitation',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                org: { type: 'string', description: 'Organization name' },
-                invitee_id: { type: 'number', description: 'GitHub user ID to invite' },
-                email: { type: 'string', description: 'Email address to invite' },
-                role: {
-                    type: 'string',
-                    enum: ['admin', 'direct_member', 'billing_manager'],
+        // update_webhook - Update an organization webhook
+        {
+            definition: {
+                name: 'github_orgs_update_webhook',
+                description: 'Update a webhook for an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        hook_id: {
+                            type: 'number',
+                            description: 'Webhook ID',
+                        },
+                        config_url: {
+                            type: 'string',
+                            description: 'URL to receive webhook payloads',
+                        },
+                        config_content_type: {
+                            type: 'string',
+                            enum: ['json', 'form'],
+                            description: 'Content type for payloads',
+                        },
+                        config_secret: {
+                            type: 'string',
+                            description: 'Secret for webhook signature',
+                        },
+                        config_insecure_ssl: {
+                            type: 'string',
+                            enum: ['0', '1'],
+                            description: 'Allow insecure SSL (0 = no, 1 = yes)',
+                        },
+                        events: {
+                            type: 'string',
+                            description: 'Comma-separated list of events to subscribe to',
+                        },
+                        active: {
+                            type: 'string',
+                            enum: ['true', 'false'],
+                            description: 'Whether the webhook is active',
+                        },
+                    },
+                    required: ['org', 'hook_id'],
                 },
-                team_ids: {
-                    type: 'array',
-                    items: { type: 'number' },
-                    description: 'Team IDs to add user to',
+            },
+            handler: async (octokit, args) => {
+                const events = args.events
+                    ? args.events.split(',').map((e) => e.trim())
+                    : undefined;
+                const config = args.config_url ? {
+                    url: args.config_url,
+                    content_type: args.config_content_type,
+                    secret: args.config_secret,
+                    insecure_ssl: args.config_insecure_ssl,
+                } : undefined;
+                const { data } = await octokit.orgs.updateWebhook({
+                    org: args.org,
+                    hook_id: args.hook_id,
+                    config,
+                    events,
+                    active: args.active !== undefined ? args.active === 'true' : undefined,
+                });
+                return successResult(data);
+            },
+        },
+        // delete_webhook - Delete an organization webhook
+        {
+            definition: {
+                name: 'github_orgs_delete_webhook',
+                description: 'Delete a webhook for an organization',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        org: {
+                            type: 'string',
+                            description: 'Organization name',
+                        },
+                        hook_id: {
+                            type: 'number',
+                            description: 'Webhook ID',
+                        },
+                    },
+                    required: ['org', 'hook_id'],
                 },
             },
-            required: ['org'],
+            handler: async (octokit, args) => {
+                await octokit.orgs.deleteWebhook({
+                    org: args.org,
+                    hook_id: args.hook_id,
+                });
+                return successResult({ success: true, message: 'Webhook deleted' });
+            },
         },
-    },
-];
-export async function handleOrgsTool(octokit, args) {
-    const org = args.org;
-    const username = args.username;
-    const teamSlug = args.team_slug;
-    // List for authenticated user
-    if (!org && !username) {
-        const { data } = await octokit.orgs.listForAuthenticatedUser(args);
-        return data;
-    }
-    // List for user
-    if (username && !org) {
-        const { data } = await octokit.orgs.listForUser(args);
-        return data;
-    }
-    // Get organization
-    if (org && !username && !teamSlug && !('name' in args) && !('filter' in args) && !('role' in args) && !('invitee_id' in args) && !('email' in args)) {
-        const { data } = await octokit.orgs.get({ org });
-        return data;
-    }
-    // Update organization
-    if (org && !username && !teamSlug && ('billing_email' in args || 'company' in args || 'email' in args || 'twitter_username' in args || 'location' in args || 'name' in args || 'description' in args)) {
-        const { data } = await octokit.orgs.update(args);
-        return data;
-    }
-    // List members
-    if (org && !username && !teamSlug && ('filter' in args || 'role' in args)) {
-        const { data } = await octokit.orgs.listMembers(args);
-        return data;
-    }
-    // Check membership
-    if (org && username && !teamSlug && !('role' in args)) {
-        try {
-            await octokit.orgs.checkMembershipForUser({ org, username });
-            return { isMember: true };
-        }
-        catch {
-            return { isMember: false };
-        }
-    }
-    // Get membership
-    if (org && username && !teamSlug && !('role' in args)) {
-        const { data } = await octokit.orgs.getMembershipForUser({ org, username });
-        return data;
-    }
-    // Set membership
-    if (org && username && !teamSlug && 'role' in args) {
-        const { data } = await octokit.orgs.setMembershipForUser(args);
-        return data;
-    }
-    // List teams
-    if (org && !teamSlug && !username && !('name' in args)) {
-        const { data } = await octokit.teams.list({ org, ...args });
-        return data;
-    }
-    // Get team
-    if (org && teamSlug && !username && !('name' in args) && !('permission' in args) && Object.keys(args).filter(k => !['org', 'team_slug', 'per_page', 'page'].includes(k)).length === 0) {
-        if ('per_page' in args || 'page' in args) {
-            // List team members
-            const { data } = await octokit.teams.listMembersInOrg(args);
-            return data;
-        }
-        const { data } = await octokit.teams.getByName({ org, team_slug: teamSlug });
-        return data;
-    }
-    // Create team
-    if (org && !teamSlug && 'name' in args) {
-        const { data } = await octokit.teams.create(args);
-        return data;
-    }
-    // Update team
-    if (org && teamSlug && ('name' in args || 'description' in args || 'privacy' in args)) {
-        const { data } = await octokit.teams.updateInOrg(args);
-        return data;
-    }
-    // Delete team
-    if (org && teamSlug && Object.keys(args).length === 2) {
-        await octokit.teams.deleteInOrg({ org, team_slug: teamSlug });
-        return { success: true, message: 'Team deleted' };
-    }
-    // Add team member
-    if (org && teamSlug && username) {
-        const { data } = await octokit.teams.addOrUpdateMembershipForUserInOrg(args);
-        return data;
-    }
-    // Add team repo
-    if (org && teamSlug && 'owner' in args && 'repo' in args) {
-        await octokit.teams.addOrUpdateRepoPermissionsInOrg(args);
-        return { success: true, message: 'Repository added to team' };
-    }
-    // List invitations
-    if (org && !teamSlug && !username && !('name' in args)) {
-        const { data } = await octokit.orgs.listPendingInvitations({ org, ...args });
-        return data;
-    }
-    // Create invitation
-    if (org && ('invitee_id' in args || 'email' in args)) {
-        const { data } = await octokit.orgs.createInvitation(args);
-        return data;
-    }
-    // Default: list for authenticated user
-    const { data } = await octokit.orgs.listForAuthenticatedUser();
-    return data;
-}
-//# sourceMappingURL=orgs.js.map
+    ],
+};