github-pro-mcp 0.0.1

package/dist/tools/labels.js

@@ -0,0 +1,87 @@
+import * as z from "zod/v4";
+import { createClient } from "../client.js";
+import { handleGitHubError } from "../utils/errors.js";
+import { validatePinnedOwnerRepo } from "../utils/validation.js";
+import { OwnerRepoSchema, PaginationSchema } from "../utils/types.js";
+export function registerLabelList(server) {
+    server.registerTool("label_list", {
+        description: "List labels in a GitHub repository.",
+        inputSchema: OwnerRepoSchema.extend({
+            page: PaginationSchema.shape.page,
+            per_page: PaginationSchema.shape.per_page,
+        }),
+    }, async ({ owner, repo, page, per_page }) => {
+        try {
+            const pinErr = validatePinnedOwnerRepo(owner, repo);
+            if (pinErr)
+                return pinErr;
+            const octokit = createClient();
+            const { data } = await octokit.rest.issues.listLabelsForRepo({ owner, repo, page, per_page });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data.map((l) => ({
+                            name: l.name,
+                            color: l.color,
+                            description: l.description,
+                            default: l.default,
+                        })), null, 2) }],
+            };
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}
+export function registerLabelWrite(server) {
+    server.registerTool("label_write", {
+        description: "Create, update, or delete a label in a GitHub repository. Method 'create' requires name and color. Method 'update' requires name (current name) and optional color/description/new_name. Method 'delete' requires name only.",
+        inputSchema: OwnerRepoSchema.extend({
+            method: z.enum(["create", "update", "delete"]).describe("Action to perform on the label"),
+            name: z.string().min(1).describe("Label name (for update: current name)"),
+            color: z.string().regex(/^[0-9a-fA-F]{6}$/).optional().describe("6-character hex color without # (required for create)"),
+            description: z.string().optional().describe("Label description"),
+            new_name: z.string().optional().describe("New name for rename (update only)"),
+        }),
+    }, async ({ owner, repo, method, name, color, description, new_name }) => {
+        try {
+            const pinErr = validatePinnedOwnerRepo(owner, repo);
+            if (pinErr)
+                return pinErr;
+            const octokit = createClient();
+            if (method === "create") {
+                if (!color) {
+                    return {
+                        content: [{ type: "text", text: "color is required for creating a label (6-char hex without #)" }],
+                        isError: true,
+                    };
+                }
+                const { data } = await octokit.rest.issues.createLabel({ owner, repo, name, color, description });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                name: data.name,
+                                color: data.color,
+                                description: data.description,
+                            }, null, 2) }],
+                };
+            }
+            else if (method === "update") {
+                const { data } = await octokit.rest.issues.updateLabel({ owner, repo, name, color, description, new_name });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                name: data.name,
+                                color: data.color,
+                                description: data.description,
+                            }, null, 2) }],
+                };
+            }
+            else {
+                await octokit.rest.issues.deleteLabel({ owner, repo, name });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ success: true, deleted: name }, null, 2) }],
+                };
+            }
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}

package/dist/tools/organizations.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerOrganizationSearch(server: McpServer): void;
+export declare function registerOwnerListIssueType(server: McpServer): void;
+export declare function registerOwnerListOrganization(server: McpServer): void;

package/dist/tools/organizations.js

@@ -0,0 +1,89 @@
+import * as z from "zod/v4";
+import { createClient, getWebBaseUrl } from "../client.js";
+import { handleGitHubError } from "../utils/errors.js";
+import { PaginationSchema } from "../utils/types.js";
+import { requireOrg, requireUser, validatePinnedOwnerRepo } from "../utils/validation.js";
+export function registerOrganizationSearch(server) {
+    server.registerTool("organization_search", {
+        description: "Search for organizations on GitHub by query. Supports qualifiers like 'location:...', 'repos:>...'.",
+        inputSchema: z.object({
+            query: z.string().min(1).describe("Search query, e.g., 'microsoft' or 'location:seattle repos:>5'"),
+            page: PaginationSchema.shape.page,
+            per_page: PaginationSchema.shape.per_page,
+        }),
+    }, async ({ query, page, per_page }) => {
+        try {
+            const octokit = createClient();
+            const { data } = await octokit.rest.search.users({ q: `${query}+type:org`, page, per_page });
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            total_count: data.total_count,
+                            items: data.items.map((u) => {
+                                const item = u;
+                                return {
+                                    login: item.login,
+                                    description: item.description ?? null,
+                                    html_url: item.html_url,
+                                };
+                            }),
+                        }, null, 2) }],
+            };
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}
+export function registerOwnerListIssueType(server) {
+    server.registerTool("owner_list_issue_type", {
+        description: "List issue types for an organization (e.g., Bug, Feature, Enhancement). Owner must be an organization.",
+        inputSchema: z.object({
+            owner: z.string().min(1).describe("Organization owner"),
+        }),
+    }, async ({ owner }) => {
+        try {
+            const pinErr = validatePinnedOwnerRepo(owner);
+            if (pinErr)
+                return pinErr;
+            const octokit = createClient();
+            const orgErr = await requireOrg(owner);
+            if (orgErr)
+                return orgErr;
+            const { data } = await octokit.request('GET /orgs/{owner}/issue-types', { owner });
+            return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}
+export function registerOwnerListOrganization(server) {
+    server.registerTool("owner_list_organization", {
+        description: "List all organizations that a user account belongs to. Provide a username, not an organization name.",
+        inputSchema: z.object({
+            owner: z.string().min(1).describe("Username to list organizations for"),
+        }),
+    }, async ({ owner }) => {
+        try {
+            const pinErr = validatePinnedOwnerRepo(owner);
+            if (pinErr)
+                return pinErr;
+            const octokit = createClient();
+            const userErr = await requireUser(owner);
+            if (userErr)
+                return userErr;
+            const { data } = await octokit.rest.orgs.listForUser({ username: owner });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data.map((o) => ({
+                            login: o.login,
+                            description: o.description,
+                            avatar_url: o.avatar_url,
+                            html_url: `${getWebBaseUrl()}/${o.login}`,
+                        })), null, 2) }],
+            };
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}

package/dist/tools/projects.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerOwnerListProject(server: McpServer): void;
+export declare function registerProjectsGet(server: McpServer): void;
+export declare function registerProjectsWrite(server: McpServer): void;

package/dist/tools/projects.js

@@ -0,0 +1,474 @@
+import * as z from "zod/v4";
+import { gql } from "../client.js";
+import { handleGitHubError } from "../utils/errors.js";
+import { validatePinnedOwnerRepo } from "../utils/validation.js";
+export function registerOwnerListProject(server) {
+    server.registerTool("owner_list_project", {
+        description: "List GitHub Projects (v2) for an owner. Works for both organizations and individual users.",
+        inputSchema: z.object({
+            owner: z.string().min(1).describe("Organization or user login"),
+            owner_type: z.enum(["org", "user"]).describe("Type of owner: 'org' for organization, 'user' for individual user"),
+            state: z.enum(["open", "closed"]).optional().describe("Filter by project state"),
+            first: z.number().int().min(1).max(100).optional().default(30).describe("Results per page (max 100)"),
+            after: z.string().optional().describe("Cursor for pagination (endCursor from previous response)"),
+        }),
+    }, async ({ owner, owner_type, state, first, after }) => {
+        try {
+            const pinErr = validatePinnedOwnerRepo(owner);
+            if (pinErr)
+                return pinErr;
+            if (owner_type === "org") {
+                const gqlQuery = `
+            query($owner: String!, $first: Int!, $after: String, $searchStr: String) {
+              organization(login: $owner) {
+                projectsV2(first: $first, after: $after, query: $searchStr) {
+                  nodes {
+                    id
+                    number
+                    title
+                    shortDescription
+                    url
+                    closed
+                    createdAt
+                    updatedAt
+                  }
+                  pageInfo {
+                    hasNextPage
+                    endCursor
+                  }
+                }
+              }
+            }
+          `;
+                const data = await gql(gqlQuery, {
+                    owner, first, after: after ?? null, searchStr: state ? `is:${state}` : null,
+                });
+                const org = data.organization;
+                if (!org) {
+                    return {
+                        content: [{ type: "text", text: `Organization "${owner}" not found.` }],
+                        isError: true,
+                    };
+                }
+                const projects = org.projectsV2?.nodes ?? [];
+                const pageInfo = org.projectsV2?.pageInfo;
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                projects: projects.map((p) => ({
+                                    id: p.id,
+                                    number: p.number,
+                                    title: p.title,
+                                    description: p.shortDescription,
+                                    url: p.url,
+                                    closed: p.closed,
+                                    created_at: p.createdAt,
+                                    updated_at: p.updatedAt,
+                                })),
+                                page_info: {
+                                    has_next_page: pageInfo?.hasNextPage ?? false,
+                                    end_cursor: pageInfo?.endCursor ?? null,
+                                },
+                            }, null, 2) }],
+                };
+            }
+            else {
+                const gqlQuery = `
+            query($owner: String!, $first: Int!, $after: String, $searchStr: String) {
+              user(login: $owner) {
+                projectsV2(first: $first, after: $after, query: $searchStr) {
+                  nodes {
+                    id
+                    number
+                    title
+                    shortDescription
+                    url
+                    closed
+                    createdAt
+                    updatedAt
+                  }
+                  pageInfo {
+                    hasNextPage
+                    endCursor
+                  }
+                }
+              }
+            }
+          `;
+                const data = await gql(gqlQuery, {
+                    owner, first, after: after ?? null, searchStr: state ? `is:${state}` : null,
+                });
+                const user = data.user;
+                if (!user) {
+                    return {
+                        content: [{ type: "text", text: `User "${owner}" not found.` }],
+                        isError: true,
+                    };
+                }
+                const projects = user.projectsV2?.nodes ?? [];
+                const pageInfo = user.projectsV2?.pageInfo;
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                projects: projects.map((p) => ({
+                                    id: p.id,
+                                    number: p.number,
+                                    title: p.title,
+                                    description: p.shortDescription,
+                                    url: p.url,
+                                    closed: p.closed,
+                                    created_at: p.createdAt,
+                                    updated_at: p.updatedAt,
+                                })),
+                                page_info: {
+                                    has_next_page: pageInfo?.hasNextPage ?? false,
+                                    end_cursor: pageInfo?.endCursor ?? null,
+                                },
+                            }, null, 2) }],
+                };
+            }
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}
+function formatFieldValue(fv) {
+    if (fv.name !== undefined)
+        return { field: fv.field?.name, value: fv.name };
+    if (fv.text !== undefined)
+        return { field: fv.field?.name, value: fv.text };
+    if (fv.number !== undefined)
+        return { field: fv.field?.name, value: fv.number };
+    if (fv.date !== undefined)
+        return { field: fv.field?.name, value: fv.date };
+    if (fv.title !== undefined)
+        return { field: fv.field?.name, value: fv.title };
+    return { value: null };
+}
+function formatProjectItem(item) {
+    return {
+        id: item.id,
+        type: item.type,
+        content: item.content ? {
+            number: item.content.number,
+            title: item.content.title,
+            state: item.content.state,
+            url: item.content.url,
+            assignees: item.content.assignees?.nodes?.map((a) => a.login) ?? [],
+        } : null,
+        field_values: item.fieldValues?.nodes?.map(formatFieldValue) ?? [],
+    };
+}
+export function registerProjectsGet(server) {
+    server.registerTool("projects_get", {
+        description: "Get a single GitHub Project (v2) by its GraphQL node ID with optional fields, items, and status updates. Each include_* flag makes additional API calls.",
+        inputSchema: z.object({
+            project_id: z.string().min(1).describe("GraphQL node ID of the project (obtain from owner_list_project)"),
+            include_fields: z.boolean().optional().default(false).describe("Include project field definitions"),
+            include_items: z.boolean().optional().default(false).describe("Include project items (issues/PRs)"),
+            include_status_updates: z.boolean().optional().default(false).describe("Include status updates"),
+            max_fields: z.number().int().positive().optional().default(20).describe("Maximum number of project field definitions to return (default: 20)"),
+            max_items: z.number().int().positive().optional().default(50).describe("Maximum number of project items to return (default: 50)"),
+            max_status_updates: z.number().int().positive().optional().default(20).describe("Maximum number of status updates to return (default: 20)"),
+            max_field_values: z.number().int().positive().optional().default(20).describe("Maximum number of field values per item (default: 20)"),
+        }),
+    }, async ({ project_id, include_fields, include_items, include_status_updates, max_fields, max_items, max_status_updates, max_field_values }) => {
+        try {
+            const fieldsLimit = max_fields ?? 20;
+            const itemsLimit = max_items ?? 50;
+            const statusUpdatesLimit = max_status_updates ?? 20;
+            const fieldValueLimit = max_field_values ?? 20;
+            const fieldsFragment = include_fields ? `
+          fields(first: ${fieldsLimit}) {
+            nodes {
+              ... on ProjectV2Field {
+                id name dataType
+              }
+              ... on ProjectV2SingleSelectField {
+                id name dataType
+                options { id name color }
+              }
+              ... on ProjectV2IterationField {
+                id name dataType
+                configuration { iterations { id title startDate duration } }
+              }
+            }
+          }
+        ` : "";
+            const itemsFragment = include_items ? `
+          items(first: ${itemsLimit}) {
+            nodes {
+              id
+              type
+              fieldValues(first: ${fieldValueLimit}) {
+                nodes {
+                  ... on ProjectV2ItemFieldSingleSelectValue {
+                    name optionId field { ... on ProjectV2SingleSelectField { id name } }
+                  }
+                  ... on ProjectV2ItemFieldTextValue {
+                    text field { ... on ProjectV2Field { id name } }
+                  }
+                  ... on ProjectV2ItemFieldNumberValue {
+                    number field { ... on ProjectV2Field { id name } }
+                  }
+                  ... on ProjectV2ItemFieldDateValue {
+                    date field { ... on ProjectV2Field { id name } }
+                  }
+                  ... on ProjectV2ItemFieldIterationValue {
+                    title field { ... on ProjectV2IterationField { id name } }
+                  }
+                }
+              }
+              content {
+                ... on Issue { number title state url assignees(first: 5) { nodes { login } } }
+                ... on PullRequest { number title state url }
+              }
+            }
+          }
+        ` : "";
+            const statusUpdatesFragment = include_status_updates ? `
+          statusUpdates(first: ${statusUpdatesLimit}) {
+            nodes {
+              id
+              body
+              status
+              createdAt
+              updatedAt
+              startDate
+              targetDate
+            }
+          }
+        ` : "";
+            const query = `
+          query($id: ID!) {
+            node(id: $id) {
+              ... on ProjectV2 {
+                id
+                number
+                title
+                shortDescription
+                url
+                closed
+                closedAt
+                createdAt
+                updatedAt
+                ${fieldsFragment}
+                ${itemsFragment}
+                ${statusUpdatesFragment}
+              }
+            }
+          }
+        `;
+            const data = await gql(query, { id: project_id });
+            const project = data.node;
+            if (!project) {
+                return {
+                    content: [{ type: "text", text: `Project not found. Check the project_id is a valid GraphQL node ID.` }],
+                    isError: true,
+                };
+            }
+            const result = {
+                id: project.id,
+                number: project.number,
+                title: project.title,
+                description: project.shortDescription,
+                url: project.url,
+                closed: project.closed,
+                closed_at: project.closedAt,
+                created_at: project.createdAt,
+                updated_at: project.updatedAt,
+            };
+            if (include_fields) {
+                result.fields = project.fields?.nodes ?? [];
+            }
+            if (include_items) {
+                result.items = (project.items?.nodes ?? []).map(formatProjectItem);
+            }
+            if (include_status_updates) {
+                result.status_updates = project.statusUpdates?.nodes ?? [];
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}
+export function registerProjectsWrite(server) {
+    server.registerTool("projects_write", {
+        description: "Manage items in a GitHub Project (v2): add, update field values, delete items, or create status updates. Methods: add_item (requires content_id), update_item (requires item_id + field_values; field_values each need field_id, value, and value_type), delete_item (requires item_id), create_status_update (requires body; optional status/start_date/target_date). Note: update_item sends field values one at a time — if one fails, earlier updates are already committed. Check partial: true in the response.",
+        inputSchema: z.object({
+            project_id: z.string().min(1).describe("GraphQL node ID of the project"),
+            method: z.enum(["add_item", "update_item", "delete_item", "create_status_update"]).describe("Action to perform"),
+            content_id: z.string().optional().describe("GraphQL node ID of issue/PR to add (required for add_item)"),
+            issue_number: z.number().int().positive().optional().describe("Issue number (alternative to content_id — auto-resolves to node ID)"),
+            item_id: z.string().optional().describe("GraphQL node ID of the project item (required for update_item, delete_item)"),
+            field_values: z.array(z.object({
+                field_id: z.string().describe("GraphQL node ID of the project field"),
+                value: z.union([z.string(), z.number(), z.null()]).describe("Field value"),
+                value_type: z.enum(["text", "number", "date", "single_select", "iteration"]).describe("Type of the field value: single_select (option ID as string), date (ISO 8601), text, number, or iteration (iteration ID)"),
+            })).optional().describe("Field values to set (update_item)"),
+            body: z.string().optional().describe("Status update body text (create_status_update)"),
+            status: z.enum(["IN_PROGRESS", "ON_TRACK", "BLOCKED", "AT_RISK", "OFF_TRACK", "COMPLETE"]).optional().describe("Status update status (create_status_update)"),
+            start_date: z.string().optional().describe("Start date in ISO 8601 format (create_status_update)"),
+            target_date: z.string().optional().describe("Target date in ISO 8601 format (create_status_update)"),
+            owner: z.string().optional().describe("Required when using issue_number. Must match the server's configured owner if pinned."),
+            repo: z.string().optional().describe("Required when using issue_number. Must match the server's configured repository if pinned."),
+        }),
+    }, async ({ project_id, method, content_id, issue_number, item_id, field_values, body, status, start_date, target_date, owner, repo }) => {
+        try {
+            if (method === "add_item") {
+                let resolvedContentId = content_id;
+                if (!resolvedContentId && issue_number) {
+                    if (!owner || !repo) {
+                        return {
+                            content: [{ type: "text", text: "owner and repo are required when using issue_number." }],
+                            isError: true,
+                        };
+                    }
+                    const pinErr = validatePinnedOwnerRepo(owner, repo);
+                    if (pinErr)
+                        return pinErr;
+                    const idQuery = `
+              query($owner: String!, $repo: String!, $number: Int!) {
+                repository(owner: $owner, name: $repo) {
+                  issue(number: $number) { id }
+                }
+              }
+            `;
+                    const idData = await gql(idQuery, { owner, repo, number: issue_number });
+                    resolvedContentId = idData.repository?.issue?.id;
+                    if (!resolvedContentId) {
+                        return {
+                            content: [{ type: "text", text: `Could not resolve issue #${issue_number} in ${owner}/${repo}.` }],
+                            isError: true,
+                        };
+                    }
+                }
+                if (!resolvedContentId) {
+                    return {
+                        content: [{ type: "text", text: "content_id or issue_number is required for add_item." }],
+                        isError: true,
+                    };
+                }
+                const mutation = `
+            mutation($projectId: ID!, $contentId: ID!) {
+              addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+                item { id }
+              }
+            }
+          `;
+                const result = await gql(mutation, { projectId: project_id, contentId: resolvedContentId });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: true,
+                                item_id: result.addProjectV2ItemById?.item?.id,
+                            }, null, 2) }],
+                };
+            }
+            else if (method === "update_item") {
+                if (!item_id || !field_values || field_values.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "item_id and field_values are required for update_item." }],
+                        isError: true,
+                    };
+                }
+                const results = [];
+                for (const fv of field_values) {
+                    const mutation = `
+              mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $value: ProjectV2FieldValue!) {
+                updateProjectV2ItemFieldValue(input: {
+                  projectId: $projectId, itemId: $itemId, fieldId: $fieldId, value: $value
+                }) {
+                  projectV2Item { id }
+                }
+              }
+            `;
+                    let value;
+                    switch (fv.value_type) {
+                        case "single_select":
+                            value = { singleSelectOptionId: String(fv.value) };
+                            break;
+                        case "date":
+                            value = { date: fv.value };
+                            break;
+                        case "text":
+                            value = { text: String(fv.value) };
+                            break;
+                        case "number":
+                            value = { number: Number(fv.value) };
+                            break;
+                        case "iteration":
+                            value = { iterationId: String(fv.value) };
+                            break;
+                        default:
+                            value = fv.value === null ? { value: null } : { text: String(fv.value) };
+                    }
+                    const result = await gql(mutation, {
+                        projectId: project_id, itemId: item_id, fieldId: fv.field_id, value,
+                    });
+                    results.push({
+                        field_id: fv.field_id,
+                        result: result.updateProjectV2ItemFieldValue?.projectV2Item?.id ? "updated" : "failed",
+                    });
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: results.every((r) => r.result === "updated"),
+                                updates: results,
+                            }, null, 2) }],
+                };
+            }
+            else if (method === "delete_item") {
+                if (!item_id) {
+                    return {
+                        content: [{ type: "text", text: "item_id is required for delete_item." }],
+                        isError: true,
+                    };
+                }
+                const mutation = `
+            mutation($projectId: ID!, $itemId: ID!) {
+              deleteProjectV2Item(input: { projectId: $projectId, itemId: $itemId }) {
+                deletedItemId
+              }
+            }
+          `;
+                const result = await gql(mutation, { projectId: project_id, itemId: item_id });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: true,
+                                deleted_item_id: result.deleteProjectV2Item?.deletedItemId,
+                            }, null, 2) }],
+                };
+            }
+            else if (method === "create_status_update") {
+                const mutation = `
+            mutation($projectId: ID!, $body: String!, $status: ProjectV2StatusUpdateStatus, $startDate: Date, $targetDate: Date) {
+              createProjectV2StatusUpdate(input: {
+                projectId: $projectId, body: $body, status: $status, startDate: $startDate, targetDate: $targetDate
+              }) {
+                statusUpdate { id body status createdAt }
+              }
+            }
+          `;
+                const result = await gql(mutation, {
+                    projectId: project_id, body: body ?? "", status: status ?? null, startDate: start_date ?? null, targetDate: target_date ?? null,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: true,
+                                status_update: result.createProjectV2StatusUpdate?.statusUpdate,
+                            }, null, 2) }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Unknown method: ${method}` }],
+                isError: true,
+            };
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}

package/dist/tools/pull_requests.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerPullRequestRead(server: McpServer): void;
+export declare function registerPullRequestCreate(server: McpServer): void;
+export declare function registerPullRequestMerge(server: McpServer): void;