github-pro-mcp 0.0.1 → 0.0.2

package/README.md

@@ -3,11 +3,11 @@
 [![npm version](https://img.shields.io/npm/v/github-pro-mcp)](https://www.npmjs.com/package/github-pro-mcp)
 [![Docker image](https://img.shields.io/docker/v/anantanandgupta/github-pro-mcp)](https://hub.docker.com/r/anantanandgupta/github-pro-mcp)
 
-An MCP (Model Context Protocol) server providing comprehensive GitHub API access via hybrid REST + GraphQL — **32 tools across 7 domains**.
+An MCP (Model Context Protocol) server providing comprehensive GitHub API access via hybrid REST + GraphQL — **34 tools across 8 domains**.
 
 ## Features
 
-- **32 Tools** — issues, pull requests, repositories, projects v2, labels, organizations, file operations
+- **34 Tools** — issues, pull requests, repositories, projects v2, labels, organizations, file operations, server info
 - **Hybrid API** — REST for CRUD/search, GraphQL for cursor pagination and composite queries
 - **Resilient by Default** — automatic retry with exponential backoff + jitter, circuit breaker for API outages, proactive rate limit management
 - **Structured Logging** — multi-level (error/warn/info/debug) stderr output
@@ -69,6 +69,10 @@ docker run -i --rm \
 | `GITHUB_RETRY_BACKOFF_MS` | `1000` | Initial retry backoff (ms) |
 | `GITHUB_CIRCUIT_BREAKER_THRESHOLD` | `5` | Failures before circuit opens |
 | `GITHUB_CIRCUIT_BREAKER_RESET_MS` | `30000` | Circuit recovery timeout (ms) |
+| `GITHUB_RETRY_BACKOFF_FACTOR` | `2` | Exponential backoff multiplier |
+| `GITHUB_OWNER_TYPE_CACHE_MS` | `300000` | Cache TTL for owner type lookups (5 min) |
+| `GITHUB_THROTTLE_ON_RATE_LIMIT` | `retry` | Primary rate limit strategy: `retry` or `queue` |
+| `GITHUB_THROTTLE_ON_SECONDARY_RATE_LIMIT` | `retry` | Secondary rate limit strategy: `retry` or `queue` |
 | `GITHUB_LOG_LEVEL` | `error` | Log level: `error`, `warn`, `info`, `debug` |
 
 ## Usage with opencode
@@ -109,14 +113,15 @@ For Docker-based usage:
 
 | Domain | Tools | Count |
 |--------|-------|-------|
-| **User & Repos** | `auth_get_current_login`, `file_get_content`, `profile_get`, `owner_list_repository`, `file_create_update`, `code_search`, `repository_search` | 7 |
+| **User & Repos** | `auth_get_current_login`, `file_get_content`, `profile_get`, `owner_list_repository`, `file_create_update`, `file_delete`, `code_search`, `repository_search` | 8 |
 | **Issues** | `issue_read`, `issue_list`, `issue_search`, `issue_add_comment`, `sub_issue_write`, `issue_create`, `issue_close`, `issue_reopen`, `issue_update`, `issue_add_label`, `issue_remove_label` | 11 |
 | **Issue Fields** | `owner_list_issue_field`, `issue_get_field_value`, `issue_set_field_value` | 3 |
 | **Pull Requests** | `pull_request_read`, `pull_request_create`, `pull_request_merge` | 3 |
 | **Organizations** | `organization_search`, `owner_list_issue_type`, `owner_list_organization` | 3 |
 | **Projects v2** | `owner_list_project`, `projects_get`, `projects_write` | 3 |
 | **Labels** | `label_list`, `label_write` | 2 |
-| **Total** | | **32** |
+| **Server Info** | `server_info` | 1 |
+| **Total** | | **34** |
 
 ## FAQ / Troubleshooting
 

package/dist/client.d.ts

@@ -4,8 +4,9 @@ export type OctokitWithRest = Octokit & {
     rest: Api["rest"];
 };
 /**
- * Creates an authenticated Octokit client with all plugins configured.
+ * Creates a lazy singleton Octokit client with all plugins configured.
  *
+ * The singleton preserves throttling queue state across calls.
  * The returned client wraps all REST requests through:
  *   circuit breaker → retry → throttling → GitHub API
  *

package/dist/client.js

@@ -11,9 +11,11 @@ const MyOctokit = Octokit
     .plugin(restEndpointMethods)
     .plugin(paginateGraphQL)
     .plugin(throttling);
+let cachedClient = null;
 /**
- * Creates an authenticated Octokit client with all plugins configured.
+ * Creates a lazy singleton Octokit client with all plugins configured.
  *
+ * The singleton preserves throttling queue state across calls.
  * The returned client wraps all REST requests through:
  *   circuit breaker → retry → throttling → GitHub API
  *
@@ -21,6 +23,8 @@ const MyOctokit = Octokit
  * via `updateRateLimits()`.
  */
 export function createClient() {
+    if (cachedClient)
+        return cachedClient;
     const token = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
     if (!token) {
         throw new Error("GITHUB_PERSONAL_ACCESS_TOKEN environment variable is not set. " +
@@ -53,6 +57,7 @@ export function createClient() {
         const label = `REST ${options.method} ${options.url}`;
         return withCircuitBreaker(() => withRetry(() => Promise.resolve(request(options)), label), "github-rest");
     });
+    cachedClient = octokit;
     return octokit;
 }
 /**

package/dist/index.js

@@ -1,16 +1,33 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { registerAuthGetCurrentLogin, registerFileGetContent, registerProfileGet, registerOwnerListRepository, registerFileCreateUpdate, registerCodeSearch, registerRepositorySearch, } from "./tools/repos.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+import { registerAuthGetCurrentLogin, registerFileGetContent, registerProfileGet, registerOwnerListRepository, registerFileCreateUpdate, registerFileDelete, registerCodeSearch, registerRepositorySearch, } from "./tools/repos.js";
 import { registerOrganizationSearch, registerOwnerListIssueType, registerOwnerListOrganization, } from "./tools/organizations.js";
 import { registerPullRequestRead, registerPullRequestCreate, registerPullRequestMerge, } from "./tools/pull_requests.js";
 import { registerIssueRead, registerIssueList, registerIssueSearch, registerIssueAddComment, registerSubIssueWrite, registerIssueCreate, registerIssueClose, registerIssueReopen, registerIssueUpdate, registerIssueAddLabel, registerIssueRemoveLabel, } from "./tools/issues.js";
 import { registerOwnerListIssueField, registerIssueGetFieldValue, registerIssueSetFieldValue, } from "./tools/issue_fields.js";
 import { registerLabelList, registerLabelWrite, } from "./tools/labels.js";
 import { registerOwnerListProject, registerProjectsGet, registerProjectsWrite, } from "./tools/projects.js";
-const server = new McpServer({ name: "github-pro-mcp", version: "2.0.1" }, { capabilities: { tools: {} } });
+import { registerServerInfo } from "./tools/server.js";
+const server = new McpServer({ name: pkg.name, version: pkg.version }, { capabilities: { tools: {} } });
+const serverMeta = {
+    name: pkg.name,
+    version: pkg.version,
+    description: pkg.description,
+    author: pkg.author,
+    license: pkg.license,
+    repository: pkg.repository?.url ?? "",
+    homepage: pkg.homepage ?? "",
+    bug_tracker: pkg.bugs?.url ?? "",
+    bin: pkg.bin ?? {},
+    tool_count: 34,
+};
 registerAuthGetCurrentLogin(server);
 registerFileGetContent(server);
+registerFileDelete(server);
 registerProfileGet(server);
 registerOwnerListRepository(server);
 registerFileCreateUpdate(server);
@@ -41,6 +58,7 @@ registerLabelWrite(server);
 registerOwnerListProject(server);
 registerProjectsGet(server);
 registerProjectsWrite(server);
+registerServerInfo(server, serverMeta);
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/issue_fields.js

@@ -64,13 +64,17 @@ export function registerIssueSetFieldValue(server) {
             if (pinErr)
                 return pinErr;
             const octokit = createClient();
+            const nameFields = fields.filter((f) => !f.field_id && f.field_name);
+            let fieldDefs = null;
+            if (nameFields.length > 0) {
+                const { data } = await octokit.request('GET /orgs/{owner}/issue-fields', { owner });
+                fieldDefs = data;
+            }
             const resolvedFields = [];
             for (const f of fields) {
                 let fieldId = f.field_id;
                 if (!fieldId && f.field_name) {
-                    const fieldName = f.field_name;
-                    const { data: fieldDefs } = await octokit.request('GET /orgs/{owner}/issue-fields', { owner });
-                    const matching = fieldDefs.find((fd) => fd.name.toLowerCase() === fieldName.toLowerCase());
+                    const matching = fieldDefs.find((fd) => fd.name.toLowerCase() === f.field_name.toLowerCase());
                     if (!matching) {
                         return {
                             content: [{ type: "text", text: `Field "${f.field_name}" not found. Available fields: ${fieldDefs.map((fd) => fd.name).join(", ")}` }],

package/dist/tools/issues.js

@@ -1,7 +1,7 @@
 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 { validatePinnedOwnerRepo, requireIssueOpen } from "../utils/validation.js";
 import { OwnerRepoSchema, PaginationSchema, IssueNumberSchema, IncludeFlagsSchema } from "../utils/types.js";
 export function registerIssueRead(server) {
     server.registerTool("issue_read", {
@@ -53,17 +53,17 @@ export function registerIssueRead(server) {
             if (include_labels) {
                 const labelLimit = max_labels ?? 20;
                 const query = `
-            query($owner: String!, $repo: String!, $number: Int!) {
+            query($owner: String!, $repo: String!, $number: Int!, $labelLimit: Int!) {
               repository(owner: $owner, name: $repo) {
                 issue(number: $number) {
-                  labels(first: ${labelLimit}) {
+                  labels(first: $labelLimit) {
                     nodes { name color description }
                   }
                 }
               }
             }
           `;
-                const labelData = await gql(query, { owner, repo, number: issue_number });
+                const labelData = await gql(query, { owner, repo, number: issue_number, labelLimit });
                 result.labels_graphql = labelData.repository?.issue?.labels?.nodes ?? [];
             }
             if (include_fields) {
@@ -72,17 +72,17 @@ export function registerIssueRead(server) {
             if (include_sub_issues) {
                 const subLimit = max_sub_issues ?? 20;
                 const query = `
-            query($owner: String!, $repo: String!, $number: Int!) {
+            query($owner: String!, $repo: String!, $number: Int!, $subLimit: Int!) {
               repository(owner: $owner, name: $repo) {
                 issue(number: $number) {
-                  subIssues(first: ${subLimit}) {
+                  subIssues(first: $subLimit) {
                     nodes { number title state }
                   }
                 }
               }
             }
           `;
-                const subData = await gql(query, { owner, repo, number: issue_number });
+                const subData = await gql(query, { owner, repo, number: issue_number, subLimit });
                 result.sub_issues = subData.repository?.issue?.subIssues?.nodes ?? [];
             }
             return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
@@ -96,7 +96,7 @@ 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"),
+            state: z.enum(["open", "closed", "all"]).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,
@@ -129,18 +129,18 @@ export function registerIssueList(server) {
                     fieldIdToName = null;
                 }
             }
-            const restParams = { owner, repo, per_page, page };
+            const restParams = { owner, repo, per_page, page, sort: "updated", direction: "desc" };
             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) }] };
+                return { content: [{ type: "text", text: JSON.stringify({ total: 0, page, per_page, issues: [] }, null, 2) }] };
             }
             let projectMap = null;
             if (needProjectFields) {
-                const gqlStates = state ? [state.toUpperCase()] : null;
+                const gqlStates = state && state !== "all" ? [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!]) {
@@ -169,10 +169,11 @@ export function registerIssueList(server) {
             }
           `;
                 const gqlResult = await gql(gqlQuery, {
-                    owner, repo, first: per_page, states: gqlStates, labels: gqlLabels,
+                    owner, repo, first: page * per_page, states: gqlStates, labels: gqlLabels,
                 });
                 projectMap = new Map();
-                for (const node of gqlResult.repository?.issues?.nodes ?? []) {
+                const skipItems = (page - 1) * per_page;
+                for (const node of (gqlResult.repository?.issues?.nodes ?? []).slice(skipItems)) {
                     projectMap.set(node.number, (node.projectItems?.nodes ?? []));
                 }
             }
@@ -301,28 +302,32 @@ 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'"),
+            query: z.string().min(1).max(1000).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 });
+            const searchQuery = query.includes("is:issue") ? query : `${query} is:issue`;
+            const { data } = await octokit.rest.search.issuesAndPullRequests({ q: searchQuery, page, per_page });
+            const items = data.items
+                .filter((i) => !i.pull_request)
+                .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)) ?? [],
+            }));
             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)) ?? [],
-                            })),
+                            items,
                         }, null, 2) }],
             };
         }
@@ -474,9 +479,15 @@ export function registerIssueClose(server) {
             const octokit = createClient();
             const { data } = await octokit.rest.issues.update({ owner, repo, issue_number, state: "closed" });
             let commentPosted = false;
+            let commentError;
             if (comment) {
-                await octokit.rest.issues.createComment({ owner, repo, issue_number, body: comment });
-                commentPosted = true;
+                try {
+                    await octokit.rest.issues.createComment({ owner, repo, issue_number, body: comment });
+                    commentPosted = true;
+                }
+                catch (e) {
+                    commentError = e instanceof Error ? e.message : String(e);
+                }
             }
             return {
                 content: [{ type: "text", text: JSON.stringify({
@@ -484,6 +495,7 @@ export function registerIssueClose(server) {
                             state: data.state,
                             closed_at: data.closed_at,
                             comment_posted: commentPosted,
+                            comment_error: commentError,
                         }, null, 2) }],
             };
         }
@@ -525,12 +537,19 @@ export function registerIssueUpdate(server) {
             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"),
+        }).refine((data) => data.title !== undefined || data.body !== undefined || data.state !== undefined, {
+            message: "At least one of title, body, or state must be provided.",
         }),
     }, async ({ owner, repo, issue_number, title, body, state }) => {
         try {
             const pinErr = validatePinnedOwnerRepo(owner, repo);
             if (pinErr)
                 return pinErr;
+            if (title !== undefined || body !== undefined) {
+                const closedErr = await requireIssueOpen(owner, repo, issue_number);
+                if (closedErr)
+                    return closedErr;
+            }
             const octokit = createClient();
             const { data } = await octokit.rest.issues.update({ owner, repo, issue_number, title, body, state });
             return {
@@ -588,15 +607,23 @@ export function registerIssueRemoveLabel(server) {
             if (pinErr)
                 return pinErr;
             const octokit = createClient();
-            const results = [];
+            const removed = [];
+            const failed = [];
             for (const label of labels) {
-                await octokit.rest.issues.removeLabel({ owner, repo, issue_number, name: label });
-                results.push(label);
+                try {
+                    await octokit.rest.issues.removeLabel({ owner, repo, issue_number, name: label });
+                    removed.push(label);
+                }
+                catch (e) {
+                    failed.push({ label, error: e instanceof Error ? e.message : String(e) });
+                }
             }
             return {
                 content: [{ type: "text", text: JSON.stringify({
-                            success: true,
-                            labels_removed: results,
+                            partial: removed.length > 0 && failed.length > 0,
+                            success: removed.length > 0,
+                            labels_removed: removed,
+                            labels_failed: failed.length > 0 ? failed : undefined,
                         }, null, 2) }],
             };
         }

package/dist/tools/organizations.js

@@ -7,7 +7,7 @@ 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'"),
+            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,
         }),

package/dist/tools/projects.js

@@ -17,114 +17,62 @@ export function registerOwnerListProject(server) {
             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 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
                 }
-              }
-            }
-          `;
-                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
-                  }
+                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;
+          }
+        `;
+            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: 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) }],
+                    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);
@@ -177,69 +125,17 @@ export function registerProjectsGet(server) {
             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!) {
+          query(
+            $id: ID!,
+            $includeFields: Boolean!,
+            $includeItems: Boolean!,
+            $includeStatusUpdates: Boolean!,
+            $fieldsLimit: Int!,
+            $itemsLimit: Int!,
+            $statusUpdatesLimit: Int!,
+            $fieldValueLimit: Int!
+          ) {
             node(id: $id) {
               ... on ProjectV2 {
                 id
@@ -251,14 +147,75 @@ export function registerProjectsGet(server) {
                 closedAt
                 createdAt
                 updatedAt
-                ${fieldsFragment}
-                ${itemsFragment}
-                ${statusUpdatesFragment}
+                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 });
+            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 {
@@ -307,10 +264,10 @@ export function registerProjectsWrite(server) {
             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)"),
+                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.enum(["IN_PROGRESS", "ON_TRACK", "BLOCKED", "AT_RISK", "OFF_TRACK", "COMPLETE"]).optional().describe("Status update status (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."),
@@ -388,22 +345,31 @@ export function registerProjectsWrite(server) {
                     let value;
                     switch (fv.value_type) {
                         case "single_select":
-                            value = { singleSelectOptionId: String(fv.value) };
+                            value = fv.value === null ? { singleSelectOptionId: null } : { singleSelectOptionId: String(fv.value) };
                             break;
                         case "date":
-                            value = { date: fv.value };
+                            value = fv.value === null ? { date: null } : { date: fv.value };
                             break;
                         case "text":
-                            value = { text: String(fv.value) };
+                            value = fv.value === null ? { text: null } : { text: String(fv.value) };
                             break;
                         case "number":
-                            value = { number: Number(fv.value) };
+                            value = fv.value === null ? { number: null } : { number: Number(fv.value) };
                             break;
                         case "iteration":
-                            value = { iterationId: String(fv.value) };
+                            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:
-                            value = fv.value === null ? { value: null } : { text: String(fv.value) };
+                            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,

package/dist/tools/pull_requests.js

@@ -101,7 +101,7 @@ export function registerPullRequestMerge(server) {
         description: "Merge a pull request in a GitHub repository.",
         inputSchema: OwnerRepoSchema.extend({
             pull_number: PullNumberSchema,
-            merge_method: z.enum(["merge", "squash", "rebase"]).optional().default("merge").describe("Merge method"),
+            merge_method: z.enum(["merge", "squash", "rebase"]).optional().default("merge").describe("Merge method — GitHub accepts: merge, squash, rebase"),
             commit_title: z.string().optional().describe("Title for merge commit"),
             commit_message: z.string().optional().describe("Extra detail for merge commit"),
         }),

package/dist/tools/repos.d.ts

@@ -5,4 +5,5 @@ export declare function registerProfileGet(server: McpServer): void;
 export declare function registerOwnerListRepository(server: McpServer): void;
 export declare function registerFileCreateUpdate(server: McpServer): void;
 export declare function registerCodeSearch(server: McpServer): void;
+export declare function registerFileDelete(server: McpServer): void;
 export declare function registerRepositorySearch(server: McpServer): void;

package/dist/tools/repos.js

@@ -100,7 +100,7 @@ export function registerOwnerListRepository(server) {
         inputSchema: z.object({
             owner: z.string().min(1).describe("Repository owner (user or organization)"),
             type: z.enum(["all", "owner", "member"]).optional().default("all").describe("Type of repositories to list (all, owner, member)"),
-            sort: z.enum(["created", "updated", "pushed", "full_name"]).optional().default("created").describe("Sort field"),
+            sort: z.enum(["created", "updated", "pushed", "full_name", "name"]).optional().default("created").describe("Sort field"),
             direction: z.enum(["asc", "desc"]).optional().describe("Sort direction (asc or desc)"),
             page: PaginationSchema.shape.page,
             per_page: PaginationSchema.shape.per_page,
@@ -111,7 +111,7 @@ export function registerOwnerListRepository(server) {
             if (pinErr)
                 return pinErr;
             const octokit = createClient();
-            const { data } = await octokit.rest.repos.listForUser({ username: owner, type, sort, direction, page, per_page });
+            const { data } = await octokit.rest.repos.listForUser({ username: owner, type, sort: sort, direction, page, per_page });
             return {
                 content: [{ type: "text", text: JSON.stringify(data.map((r) => formatRepo(r)), null, 2) }],
             };
@@ -163,7 +163,7 @@ export function registerCodeSearch(server) {
     server.registerTool("code_search", {
         description: "Search for code across GitHub repositories. Supports GitHub search qualifiers like 'repo:...', 'language:...', 'path:...'.",
         inputSchema: z.object({
-            query: z.string().min(1).describe("Search query with GitHub qualifiers, e.g., 'function repo:owner/repo language:python'"),
+            query: z.string().min(1).max(1000).describe("Search query with GitHub qualifiers, e.g., 'function repo:owner/repo language:python'"),
             page: PaginationSchema.shape.page,
             per_page: PaginationSchema.shape.per_page,
         }),
@@ -188,11 +188,45 @@ export function registerCodeSearch(server) {
         }
     });
 }
+export function registerFileDelete(server) {
+    server.registerTool("file_delete", {
+        description: "Delete a file from a GitHub repository. Requires the SHA of the file (obtain from file_get_content).",
+        inputSchema: OwnerRepoSchema.extend({
+            path: z.string().min(1).describe("Path to the file to delete"),
+            message: z.string().min(1).describe("Commit message"),
+            branch: z.string().min(1).describe("Branch to delete the file from"),
+            sha: z.string().min(1).describe("SHA of the file to delete (obtain from file_get_content or file_create_update)"),
+        }),
+    }, async ({ owner, repo, path, message, branch, sha }) => {
+        try {
+            const pinErr = validatePinnedOwnerRepo(owner, repo);
+            if (pinErr)
+                return pinErr;
+            const octokit = createClient();
+            const response = await octokit.rest.repos.deleteFile({
+                owner, repo, path, message, branch, sha,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            commit: {
+                                sha: response.data.commit.sha,
+                                message: response.data.commit.message,
+                                html_url: response.data.commit.html_url,
+                            },
+                            content: null,
+                        }, null, 2) }],
+            };
+        }
+        catch (err) {
+            return handleGitHubError(err);
+        }
+    });
+}
 export function registerRepositorySearch(server) {
     server.registerTool("repository_search", {
         description: "Search for GitHub repositories by query. Supports GitHub search qualifiers like 'org:...', 'language:...', 'stars:>100'.",
         inputSchema: z.object({
-            query: z.string().min(1).describe("Search query with GitHub qualifiers, e.g., 'org:microsoft language:python'"),
+            query: z.string().min(1).max(1000).describe("Search query with GitHub qualifiers, e.g., 'org:microsoft language:python'"),
             page: PaginationSchema.shape.page,
             per_page: PaginationSchema.shape.per_page,
         }),

package/dist/tools/server.d.ts

@@ -0,0 +1,14 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface ServerMetadata {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license: string;
+    repository: string;
+    homepage: string;
+    bug_tracker: string;
+    bin: Record<string, string>;
+    tool_count: number;
+}
+export declare function registerServerInfo(server: McpServer, meta: ServerMetadata): void;

package/dist/tools/server.js

@@ -0,0 +1,37 @@
+import * as z from "zod/v4";
+export function registerServerInfo(server, meta) {
+    server.registerTool("server_info", {
+        description: "Get information about this MCP server, including version, support links, and runtime configuration.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const runtime = {
+            node_version: process.version,
+            platform: process.platform,
+            pinned_owner: process.env.GITHUB_OWNER ?? null,
+            pinned_repo: process.env.GITHUB_REPO ?? null,
+            log_level: process.env.GITHUB_LOG_LEVEL ?? "error",
+            retry_max_attempts: parseInt(process.env.GITHUB_RETRY_MAX_ATTEMPTS ?? "3", 10),
+            circuit_breaker_threshold: parseInt(process.env.GITHUB_CIRCUIT_BREAKER_THRESHOLD ?? "5", 10),
+        };
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        name: meta.name,
+                        version: meta.version,
+                        description: meta.description,
+                        author: meta.author,
+                        license: meta.license,
+                        repository: meta.repository,
+                        homepage: meta.homepage,
+                        bug_tracker: meta.bug_tracker,
+                        npm_package: "https://www.npmjs.com/package/github-pro-mcp",
+                        docker_image: "https://hub.docker.com/r/anantanandgupta/github-pro-mcp",
+                        bin: meta.bin,
+                        tools_registered: meta.tool_count,
+                        runtime,
+                    }, null, 2),
+                }],
+        };
+    });
+}

package/dist/utils/validation.d.ts

@@ -9,4 +9,5 @@ interface ErrorResponse {
 export declare function validatePinnedOwnerRepo(owner?: string, repo?: string): ErrorResponse | null;
 export declare function requireOrg(owner: string): Promise<ErrorResponse | null>;
 export declare function requireUser(owner: string): Promise<ErrorResponse | null>;
+export declare function requireIssueOpen(owner: string, repo: string, issue_number: number): Promise<ErrorResponse | null>;
 export {};

package/dist/utils/validation.js

@@ -73,3 +73,16 @@ export async function requireUser(owner) {
     }
     return null;
 }
+export async function requireIssueOpen(owner, repo, issue_number) {
+    const octokit = createClient();
+    const { data } = await octokit.rest.issues.get({ owner, repo, issue_number });
+    if (data.state === "closed") {
+        return {
+            content: [{ type: "text", text: `Issue #${issue_number} in ${owner}/${repo} is closed. ` +
+                        `Reopen it first before modifying the title or body.`
+                }],
+            isError: true,
+        };
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-pro-mcp",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "MCP server providing GitHub API access with hybrid REST + GraphQL support",
   "main": "dist/index.js",
   "bin": {
@@ -12,15 +12,26 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "test": "node --test 'src/__tests__/**/*.test.mjs'",
+    "test": "node --test --test-global-setup='src/__tests__/setup.mjs' --test-concurrency=1 'src/__tests__/**/*.test.mjs'",
+    "test:unit": "node --test 'src/__tests__/{retry,circuit_breaker,rate_limit}.test.mjs'",
+    "test:repos": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/repos.test.mjs'",
+    "test:issues": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/issues.test.mjs'",
+    "test:issue_fields": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/issue_fields.test.mjs'",
+    "test:projects": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/projects.test.mjs'",
+    "test:orgs": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/organizations.test.mjs'",
+    "test:labels": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/labels.test.mjs'",
+    "test:prs": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/pull_requests.test.mjs'",
+    "test:write": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/write.test.mjs'",
+    "test:consistency": "node --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/consistency.test.mjs'",
     "test:docker": "node --test 'test/docker/**/*.test.mjs'",
     "test:npm": "node --test 'test/integration/**/*.test.mjs'",
     "test:all": "npm test && npm run test:docker && npm run test:npm",
-    "test:coverage": "node --experimental-test-coverage --test 'src/__tests__/**/*.test.mjs'",
+    "test:coverage": "node --experimental-test-coverage --test --test-global-setup='src/__tests__/setup.mjs' 'src/__tests__/**/*.test.mjs'",
     "test:inspector": "npx @modelcontextprotocol/inspector node dist/index.js",
     "dev": "tsc --watch",
     "prepack": "npm run build",
     "docker:build": "make docker-build",
+    "docker:build:local": "make docker-build-local",
     "docker:push": "make docker-push",
     "publish:npm": "npm run build && npm test && npm publish",
     "publish:all": "npm run publish:npm && npm run docker:push"