github-pro-mcp 0.0.2 → 0.0.4

package/dist/tools/labels.js

@@ -1,87 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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).max(1000).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

@@ -1,4 +0,0 @@
-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

@@ -1,440 +0,0 @@
-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;
-            const rootType = owner_type === "org" ? "organization" : "user";
-            const gqlQuery = `
-          query($owner: String!, $first: Int!, $after: String, $searchStr: String) {
-            ${rootType}(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 root = owner_type === "org"
-                ? data.organization
-                : data.user;
-            if (!root) {
-                const label = owner_type === "org" ? "Organization" : "User";
-                return {
-                    content: [{ type: "text", text: `${label} "${owner}" not found.` }],
-                    isError: true,
-                };
-            }
-            const projects = root.projectsV2?.nodes ?? [];
-            const pageInfo = root.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 query = `
-          query(
-            $id: ID!,
-            $includeFields: Boolean!,
-            $includeItems: Boolean!,
-            $includeStatusUpdates: Boolean!,
-            $fieldsLimit: Int!,
-            $itemsLimit: Int!,
-            $statusUpdatesLimit: Int!,
-            $fieldValueLimit: Int!
-          ) {
-            node(id: $id) {
-              ... on ProjectV2 {
-                id
-                number
-                title
-                shortDescription
-                url
-                closed
-                closedAt
-                createdAt
-                updatedAt
-                fields(first: $fieldsLimit) @include(if: $includeFields) {
-                  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 } }
-                    }
-                  }
-                }
-                items(first: $itemsLimit) @include(if: $includeItems) {
-                  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 }
-                    }
-                  }
-                }
-                statusUpdates(first: $statusUpdatesLimit) @include(if: $includeStatusUpdates) {
-                  nodes {
-                    id
-                    body
-                    status
-                    createdAt
-                    updatedAt
-                    startDate
-                    targetDate
-                  }
-                }
-              }
-            }
-          }
-        `;
-            const data = await gql(query, {
-                id: project_id,
-                includeFields: !!include_fields,
-                includeItems: !!include_items,
-                includeStatusUpdates: !!include_status_updates,
-                fieldsLimit,
-                itemsLimit,
-                statusUpdatesLimit,
-                fieldValueLimit,
-            });
-            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(["single_select", "text", "number", "date", "iteration", "title"]).describe("Type of the field value — use the field's dataType from projects_get / owner_list_project to determine the correct value_type"),
-            })).optional().describe("Field values to set (update_item)"),
-            body: z.string().optional().describe("Status update body text (create_status_update)"),
-            status: z.string().optional().describe("Status update status (create_status_update) — pass any value GitHub accepts"),
-            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 = fv.value === null ? { singleSelectOptionId: null } : { singleSelectOptionId: String(fv.value) };
-                            break;
-                        case "date":
-                            value = fv.value === null ? { date: null } : { date: fv.value };
-                            break;
-                        case "text":
-                            value = fv.value === null ? { text: null } : { text: String(fv.value) };
-                            break;
-                        case "number":
-                            value = fv.value === null ? { number: null } : { number: Number(fv.value) };
-                            break;
-                        case "iteration":
-                            value = fv.value === null ? { iterationId: null } : { iterationId: String(fv.value) };
-                            break;
-                        case "title":
-                            value = fv.value === null ? { title: null } : { title: String(fv.value) };
-                            break;
-                        default:
-                            if (fv.value === null) {
-                                return {
-                                    content: [{ type: "text", text: `Cannot clear field — unknown value_type "${fv.value_type}". Provide a valid value_type or use a known type (single_select, text, number, date, iteration, title).` }],
-                                    isError: true,
-                                };
-                            }
-                            value = { 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

@@ -1,4 +0,0 @@
-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;