github-pro-mcp 0.0.1 → 0.0.3

package/dist/tools/issues.js

@@ -1,607 +0,0 @@
-import * as z from "zod/v4";
-import { createClient, gql } from "../client.js";
-import { handleGitHubError } from "../utils/errors.js";
-import { validatePinnedOwnerRepo } from "../utils/validation.js";
-import { OwnerRepoSchema, PaginationSchema, IssueNumberSchema, IncludeFlagsSchema } from "../utils/types.js";
-export function registerIssueRead(server) {
-    server.registerTool("issue_read", {
-        description: "Get details of a specific issue. Optionally include comments, labels, field values, and sub-issues. Each include_* flag makes additional API calls.",
-        inputSchema: OwnerRepoSchema.extend({
-            issue_number: IssueNumberSchema,
-            include_comments: IncludeFlagsSchema.shape.include_comments,
-            include_labels: IncludeFlagsSchema.shape.include_labels,
-            include_fields: IncludeFlagsSchema.shape.include_fields,
-            include_sub_issues: IncludeFlagsSchema.shape.include_sub_issues,
-            max_comments: z.number().int().positive().optional().describe("Maximum number of comments to return (default: all)"),
-            max_labels: z.number().int().positive().optional().default(20).describe("Maximum number of labels to return via GraphQL"),
-            max_sub_issues: z.number().int().positive().optional().default(20).describe("Maximum number of sub-issues to return via GraphQL"),
-        }),
-    }, async ({ owner, repo, issue_number, include_comments, include_labels, include_fields, include_sub_issues, max_comments, max_labels, max_sub_issues }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data: issue } = await octokit.rest.issues.get({ owner, repo, issue_number });
-            const issueData = issue;
-            const result = {
-                number: issueData.number,
-                title: issueData.title,
-                body: issueData.body,
-                state: issueData.state,
-                html_url: issueData.html_url,
-                created_at: issueData.created_at,
-                updated_at: issueData.updated_at,
-                closed_at: issueData.closed_at,
-                user: { login: issueData.user?.login, avatar_url: issueData.user?.avatar_url },
-                labels: issueData.labels.map((l) => {
-                    if (typeof l === "string")
-                        return { name: l, color: null };
-                    return { name: l.name ?? null, color: l.color ?? null };
-                }),
-                assignees: issueData.assignees?.map((a) => a.login) ?? [],
-            };
-            if (include_comments) {
-                const { data: comments } = await octokit.rest.issues.listComments({ owner, repo, issue_number, per_page: max_comments ?? 100 });
-                result.comments = comments.map((c) => ({
-                    id: c.id,
-                    user: c.user?.login,
-                    body: c.body,
-                    created_at: c.created_at,
-                }));
-            }
-            if (include_labels) {
-                const labelLimit = max_labels ?? 20;
-                const query = `
-            query($owner: String!, $repo: String!, $number: Int!) {
-              repository(owner: $owner, name: $repo) {
-                issue(number: $number) {
-                  labels(first: ${labelLimit}) {
-                    nodes { name color description }
-                  }
-                }
-              }
-            }
-          `;
-                const labelData = await gql(query, { owner, repo, number: issue_number });
-                result.labels_graphql = labelData.repository?.issue?.labels?.nodes ?? [];
-            }
-            if (include_fields) {
-                result.field_values = issueData.issue_field_values ?? [];
-            }
-            if (include_sub_issues) {
-                const subLimit = max_sub_issues ?? 20;
-                const query = `
-            query($owner: String!, $repo: String!, $number: Int!) {
-              repository(owner: $owner, name: $repo) {
-                issue(number: $number) {
-                  subIssues(first: ${subLimit}) {
-                    nodes { number title state }
-                  }
-                }
-              }
-            }
-          `;
-                const subData = await gql(query, { owner, repo, number: issue_number });
-                result.sub_issues = subData.repository?.issue?.subIssues?.nodes ?? [];
-            }
-            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueList(server) {
-    server.registerTool("issue_list", {
-        description: "List issues in a repository. Optionally include org-level field values (Priority, Effort) and/or project board field values (Status, Application). Supports field-based filtering with filter_fields (AND logic).",
-        inputSchema: OwnerRepoSchema.extend({
-            state: z.enum(["open", "closed"]).optional().describe("Filter by issue state"),
-            labels: z.string().optional().describe("Comma-separated label names to filter by"),
-            per_page: PaginationSchema.shape.per_page,
-            page: PaginationSchema.shape.page,
-            include_fields: z.boolean().optional().default(false).describe("Include org-level field values (Priority, Effort) for each issue"),
-            include_project_fields: z.boolean().optional().default(false).describe("Include project board field values (Status, Application) for each issue"),
-            filter_fields: z.array(z.object({
-                field_name: z.string().min(1).describe("Field name to filter by, e.g. 'Priority', 'Status', 'Application'"),
-                field_value: z.string().min(1).describe("Field value to match, e.g. 'Medium', 'In Progress', 'Done'"),
-            })).optional().describe("Filter issues by field values (AND logic). All filters must match. Fetches required field data automatically."),
-        }),
-    }, async ({ owner, repo, state, labels, per_page, page, include_fields, include_project_fields, filter_fields }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const hasFilterFields = !!(filter_fields && filter_fields.length > 0);
-            const needOrgFields = include_fields || hasFilterFields;
-            const needProjectFields = include_project_fields || hasFilterFields;
-            let fieldIdToName = null;
-            if (needOrgFields) {
-                try {
-                    const { data: profile } = await octokit.rest.users.getByUsername({ username: owner });
-                    if (profile.type === "Organization") {
-                        const { data: fieldDefs } = await octokit.request('GET /orgs/{owner}/issue-fields', { owner });
-                        fieldIdToName = new Map(fieldDefs.map((fd) => [fd.id, fd.name]));
-                    }
-                }
-                catch {
-                    fieldIdToName = null;
-                }
-            }
-            const restParams = { owner, repo, per_page, page };
-            if (state)
-                restParams.state = state;
-            if (labels)
-                restParams.labels = labels;
-            const { data: restIssues } = await octokit.rest.issues.listForRepo(restParams);
-            if (!restIssues.length) {
-                return { content: [{ type: "text", text: JSON.stringify({ total: 0, issues: [] }, null, 2) }] };
-            }
-            let projectMap = null;
-            if (needProjectFields) {
-                const gqlStates = state ? [state.toUpperCase()] : null;
-                const gqlLabels = labels ? labels.split(",").map((l) => l.trim()) : null;
-                const gqlQuery = `
-            query($owner: String!, $repo: String!, $first: Int!, $states: [IssueState!], $labels: [String!]) {
-              repository(owner: $owner, name: $repo) {
-                issues(first: $first, states: $states, labels: $labels, orderBy: { field: UPDATED_AT, direction: DESC }) {
-                  nodes {
-                    number
-                    projectItems(first: 5) {
-                      nodes {
-                        project { title }
-                        fieldValues(first: 20) {
-                          nodes {
-                            __typename
-                            ... on ProjectV2ItemFieldTextValue { text field { ... on ProjectV2Field { name } ... on ProjectV2SingleSelectField { name } ... on ProjectV2IterationField { name } } }
-                            ... on ProjectV2ItemFieldSingleSelectValue { name field { ... on ProjectV2Field { name } ... on ProjectV2SingleSelectField { name } ... on ProjectV2IterationField { name } } }
-                            ... on ProjectV2ItemFieldNumberValue { number field { ... on ProjectV2Field { name } ... on ProjectV2SingleSelectField { name } ... on ProjectV2IterationField { name } } }
-                            ... on ProjectV2ItemFieldDateValue { date field { ... on ProjectV2Field { name } ... on ProjectV2SingleSelectField { name } ... on ProjectV2IterationField { name } } }
-                            ... on ProjectV2ItemFieldIterationValue { title field { ... on ProjectV2Field { name } ... on ProjectV2SingleSelectField { name } ... on ProjectV2IterationField { name } } }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          `;
-                const gqlResult = await gql(gqlQuery, {
-                    owner, repo, first: per_page, states: gqlStates, labels: gqlLabels,
-                });
-                projectMap = new Map();
-                for (const node of gqlResult.repository?.issues?.nodes ?? []) {
-                    projectMap.set(node.number, (node.projectItems?.nodes ?? []));
-                }
-            }
-            const filterNameSet = hasFilterFields ? new Set(filter_fields.map((f) => f.field_name)) : null;
-            const labelsToNames = (issueLabels) => issueLabels.map((l) => {
-                if (typeof l === "string")
-                    return { name: l, color: null };
-                return { name: l.name ?? null, color: l.color ?? null };
-            });
-            const issues = [];
-            for (const issue of restIssues) {
-                const issueData = issue;
-                const entry = {
-                    number: issueData.number,
-                    title: issueData.title,
-                    state: issueData.state,
-                    html_url: issueData.html_url,
-                    created_at: issueData.created_at,
-                    updated_at: issueData.updated_at,
-                    labels: labelsToNames(issueData.labels),
-                };
-                let orgFieldVals = null;
-                let projectFieldVals = null;
-                if (needOrgFields) {
-                    orgFieldVals = [];
-                    if (fieldIdToName && issueData.issue_field_values) {
-                        for (const fv of issueData.issue_field_values) {
-                            const fName = fieldIdToName.get(fv.issue_field_id);
-                            if (fName && (!filterNameSet || filterNameSet.has(fName))) {
-                                orgFieldVals.push({
-                                    name: fName,
-                                    value: fv.single_select_option?.name ?? String(fv.value ?? ""),
-                                });
-                            }
-                        }
-                    }
-                    if (include_fields) {
-                        entry.field_values = orgFieldVals;
-                    }
-                }
-                if (needProjectFields && projectMap) {
-                    projectFieldVals = [];
-                    const projectItems = projectMap.get(issueData.number) ?? [];
-                    for (const pi of projectItems) {
-                        const projectTitle = pi.project?.title ?? "unknown";
-                        for (const fvNode of pi.fieldValues?.nodes ?? []) {
-                            if (!fvNode)
-                                continue;
-                            const fv = fvNode;
-                            const fvFieldName = fv.field?.name;
-                            if (!fvFieldName || (filterNameSet && !filterNameSet.has(fvFieldName)))
-                                continue;
-                            let fValue = null;
-                            const typename = fv.__typename;
-                            if (typename === "ProjectV2ItemFieldSingleSelectValue")
-                                fValue = fv.name;
-                            else if (typename === "ProjectV2ItemFieldTextValue")
-                                fValue = fv.text;
-                            else if (typename === "ProjectV2ItemFieldNumberValue")
-                                fValue = String(fv.number);
-                            else if (typename === "ProjectV2ItemFieldDateValue")
-                                fValue = fv.date;
-                            else if (typename === "ProjectV2ItemFieldIterationValue")
-                                fValue = fv.title;
-                            if (fValue !== null) {
-                                projectFieldVals.push({ name: fvFieldName, value: fValue, project: projectTitle });
-                            }
-                        }
-                    }
-                    if (include_project_fields) {
-                        entry.project_fields = projectFieldVals;
-                    }
-                }
-                if (hasFilterFields) {
-                    const allFields = new Map();
-                    if (orgFieldVals) {
-                        for (const f of orgFieldVals) {
-                            if (!allFields.has(f.name))
-                                allFields.set(f.name, []);
-                            allFields.get(f.name).push({ value: f.value, source: "org_field" });
-                        }
-                    }
-                    if (projectFieldVals) {
-                        for (const f of projectFieldVals) {
-                            if (!allFields.has(f.name))
-                                allFields.set(f.name, []);
-                            allFields.get(f.name).push({ value: f.value, source: `project_board:${f.project}` });
-                        }
-                    }
-                    let allMatch = true;
-                    const matchedFields = [];
-                    for (const filter of filter_fields) {
-                        const entries = allFields.get(filter.field_name);
-                        if (!entries) {
-                            allMatch = false;
-                            break;
-                        }
-                        const match = entries.find((e) => e.value === filter.field_value);
-                        if (!match) {
-                            allMatch = false;
-                            break;
-                        }
-                        matchedFields.push({ source: match.source, field: filter.field_name, value: match.value });
-                    }
-                    if (!allMatch)
-                        continue;
-                    entry.matched_fields = matchedFields;
-                }
-                issues.push(entry);
-            }
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            total: issues.length,
-                            page,
-                            per_page,
-                            issues,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueSearch(server) {
-    server.registerTool("issue_search", {
-        description: "Search for issues in GitHub repositories using GitHub's search syntax.",
-        inputSchema: z.object({
-            query: z.string().min(1).describe("Search query using GitHub issues search syntax, e.g., 'label:bug repo:owner/repo'"),
-            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.issuesAndPullRequests({ q: query, page, per_page });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            total_count: data.total_count,
-                            items: data.items.map((i) => ({
-                                number: i.number,
-                                title: i.title,
-                                state: i.state,
-                                html_url: i.html_url,
-                                repository: i.repository?.full_name ?? null,
-                                created_at: i.created_at,
-                                updated_at: i.updated_at,
-                                user: i.user?.login,
-                                labels: i.labels?.map((l) => (typeof l === "string" ? l : l.name)) ?? [],
-                            })),
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueAddComment(server) {
-    server.registerTool("issue_add_comment", {
-        description: "Add a comment to an existing issue in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            issue_number: IssueNumberSchema,
-            body: z.string().min(1).describe("Comment content"),
-        }),
-    }, async ({ owner, repo, issue_number, body }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.issues.createComment({ owner, repo, issue_number, body });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            id: data.id,
-                            html_url: data.html_url,
-                            created_at: data.created_at,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerSubIssueWrite(server) {
-    server.registerTool("sub_issue_write", {
-        description: "Add or remove a sub-issue from a parent issue in a GitHub repository. Method 'add' adds sub_issue_number as a sub-issue of issue_number. Method 'remove' removes the sub-issue relationship.",
-        inputSchema: OwnerRepoSchema.extend({
-            method: z.enum(["add", "remove"]).describe("Operation: add or remove a sub-issue"),
-            issue_number: IssueNumberSchema,
-            sub_issue_number: z.number().int().positive().describe("Sub-issue issue number"),
-        }),
-    }, async ({ owner, repo, method, issue_number, sub_issue_number }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const idQuery = `
-          query($owner: String!, $repo: String!, $parentNumber: Int!, $subNumber: Int!) {
-            parent: repository(owner: $owner, name: $repo) {
-              issue(number: $parentNumber) { id }
-            }
-            child: repository(owner: $owner, name: $repo) {
-              issue(number: $subNumber) { id }
-            }
-          }
-        `;
-            const idData = await gql(idQuery, { owner, repo, parentNumber: issue_number, subNumber: sub_issue_number });
-            const parentId = idData.parent?.issue?.id;
-            const childId = idData.child?.issue?.id;
-            if (!parentId || !childId) {
-                return {
-                    content: [{ type: "text", text: `Could not resolve one or both issues. Parent: ${issue_number}, Sub: ${sub_issue_number}.` }],
-                    isError: true,
-                };
-            }
-            if (method === "add") {
-                const mutation = `
-            mutation($parentId: ID!, $subIssueId: ID!) {
-              addSubIssue(input: { issueId: $parentId, subIssueId: $subIssueId }) {
-                subIssue { number title state }
-              }
-            }
-          `;
-                const result = await gql(mutation, { parentId, subIssueId: childId });
-                return {
-                    content: [{ type: "text", text: JSON.stringify({
-                                success: true,
-                                sub_issue: result.addSubIssue?.subIssue,
-                            }, null, 2) }],
-                };
-            }
-            else {
-                const mutation = `
-            mutation($parentId: ID!, $subIssueId: ID!) {
-              removeSubIssue(input: { issueId: $parentId, subIssueId: $subIssueId }) {
-                issue { number title }
-              }
-            }
-          `;
-                const result = await gql(mutation, { parentId, subIssueId: childId });
-                return {
-                    content: [{ type: "text", text: JSON.stringify({
-                                success: true,
-                                parent_issue: result.removeSubIssue?.issue,
-                            }, null, 2) }],
-                };
-            }
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueCreate(server) {
-    server.registerTool("issue_create", {
-        description: "Create a new issue in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            title: z.string().min(1).describe("Issue title"),
-            body: z.string().optional().describe("Issue body content"),
-            labels: z.array(z.string()).optional().describe("Labels to apply to the issue"),
-            assignees: z.array(z.string()).optional().describe("Usernames to assign to the issue"),
-        }),
-    }, async ({ owner, repo, title, body, labels, assignees }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.issues.create({ owner, repo, title, body, labels, assignees });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            number: data.number,
-                            title: data.title,
-                            html_url: data.html_url,
-                            state: data.state,
-                            created_at: data.created_at,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueClose(server) {
-    server.registerTool("issue_close", {
-        description: "Close an issue in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            issue_number: IssueNumberSchema,
-            comment: z.string().optional().describe("Optional closing comment to leave on the issue"),
-        }),
-    }, async ({ owner, repo, issue_number, comment }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.issues.update({ owner, repo, issue_number, state: "closed" });
-            let commentPosted = false;
-            if (comment) {
-                await octokit.rest.issues.createComment({ owner, repo, issue_number, body: comment });
-                commentPosted = true;
-            }
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            number: data.number,
-                            state: data.state,
-                            closed_at: data.closed_at,
-                            comment_posted: commentPosted,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueReopen(server) {
-    server.registerTool("issue_reopen", {
-        description: "Reopen a closed issue in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            issue_number: IssueNumberSchema,
-        }),
-    }, async ({ owner, repo, issue_number }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.issues.update({ owner, repo, issue_number, state: "open" });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            number: data.number,
-                            state: data.state,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueUpdate(server) {
-    server.registerTool("issue_update", {
-        description: "Update an issue's title, body, or state in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            issue_number: IssueNumberSchema,
-            title: z.string().optional().describe("New title for the issue"),
-            body: z.string().optional().describe("New body content for the issue"),
-            state: z.enum(["open", "closed"]).optional().describe("New state for the issue"),
-        }),
-    }, async ({ owner, repo, issue_number, title, body, state }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.issues.update({ owner, repo, issue_number, title, body, state });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            number: data.number,
-                            title: data.title,
-                            body: data.body,
-                            state: data.state,
-                            html_url: data.html_url,
-                            updated_at: data.updated_at,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueAddLabel(server) {
-    server.registerTool("issue_add_label", {
-        description: "Add labels to an issue in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            issue_number: IssueNumberSchema,
-            labels: z.array(z.string()).min(1).describe("Label names to add to the issue"),
-        }),
-    }, async ({ owner, repo, issue_number, labels }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.issues.addLabels({ owner, repo, issue_number, labels });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            success: true,
-                            labels_added: data.map((l) => l.name),
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerIssueRemoveLabel(server) {
-    server.registerTool("issue_remove_label", {
-        description: "Remove labels from an issue in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            issue_number: IssueNumberSchema,
-            labels: z.array(z.string()).min(1).describe("Label names to remove from the issue"),
-        }),
-    }, async ({ owner, repo, issue_number, labels }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const results = [];
-            for (const label of labels) {
-                await octokit.rest.issues.removeLabel({ owner, repo, issue_number, name: label });
-                results.push(label);
-            }
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            success: true,
-                            labels_removed: results,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}

package/dist/tools/labels.d.ts

@@ -1,3 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerLabelList(server: McpServer): void;
-export declare function registerLabelWrite(server: McpServer): void;