Skip to content
CAI
Software that uses CAICheck a score

github/github-mcp-server

53.8

Adequate · 10 October 2026

56k

lines of production code

Go

with TypeScript

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is the GitHub MCP Server, a service that exposes GitHub capabilities—such as repository management, issue tracking, code scanning, and Actions—as Model Context Protocol tools. It handles secure authentication via OAuth 2.1 with PKCE and device flows, enforcing granular, per-call scope validation to ensure users have the necessary permissions for each operation. The server provides both stdio and HTTP transport layers, featuring dynamic tool discovery, request context management, and a suite of UI applications for interactive workflows like creating issues and pull requests.

How it got here

2025 — Infrastructure modernization and security hardening

22 changes.

This period focused on modernizing the server's core architecture by migrating to a new module path, upgrading to Go 1.25, and replacing the legacy command-line entry point with a robust Inventory system for tool management. Significant security enhancements were implemented, including strict OAuth scoping, path traversal protection, content sanitization, and offline icon embedding, alongside the introduction of new GitHub Actions and code scanning tools.

2026 — OAuth integration and UI expansion

16 changes.

This period focused on implementing comprehensive OAuth 2.0 support, including PKCE flows, per-call scope enforcement, and protected resource metadata discovery. Concurrently, the project expanded its UI capabilities by introducing new MCP Apps for issue and pull request management, alongside significant refactoring of the HTTP transport and middleware layers to support these security and feature requirements.

Features

Add I/O logging wrapper for debugging

A new IOLogger component has been added to the logging package to wrap io.Reader and io.Writer streams. When used, it transparently logs the data being read from and written to these streams using the standard library's slog logger, which aids in debugging data flow without altering the underlying I/O behavior.

pkg/log · high confidence

Add raw file API client with path traversal protection

The new \pkg/raw\ package provides a client for fetching raw file content from GitHub repositories, supporting retrieval by branch, tag, or commit SHA. It includes security validation that rejects URL components containing \..\ path segments (including those introduced via percent-encoding) to prevent path traversal attacks, and integrates with the \go-github/v89\ library for HTTP operations.

pkg/raw · high confidence

Add ring buffer for truncating large GitHub Actions job logs

The \pkg/buffer\ package now includes a new \ProcessResponseAsRingBufferToEnd\ function that efficiently processes HTTP response bodies by retaining only the last N log lines using a ring buffer. This prevents memory exhaustion when handling extremely large logs, such as those from GitHub Actions, by enforcing a 10MB per-line limit and truncating oversized lines with a marker. The implementation includes comprehensive tests covering edge cases like empty bodies, exact size boundaries, and ring buffer rotation with truncated lines.

pkg/buffer · high confidence

Add script to generate MCP configuration matrices for diff testing

A new Go script, \script/print-mcp-diff-configs\, has been added to generate the JSON configuration matrix used by the \mcp-server-diff\ GitHub Action. This tool emits configuration entries covering default settings, read-only modes, specific toolsets (repos, issues, context, pull requests), and feature flags. It supports two output transports: \stdio\ (generating CLI arguments) and \http-headers\ (generating X-MCP-\* headers for a shared HTTP server), ensuring that both local and remote server invocation modes are tested against the same logical configuration set.

script/print-mcp-diff-configs · high confidence

Add tool search CLI

Introduces a new tool search capability in the \pkg/tooldiscovery\ package, allowing users to find relevant tools via free-text queries. The implementation uses a weighted scoring system that considers matches in tool names, descriptions, and input parameter names, with fuzzy matching as a tie-breaker. Results are sorted by relevance and limited by a configurable maximum (default 3). Tests verify correct behavior for empty queries, name-based searches, and parameter-name matching across different schema formats.

pkg/tooldiscovery · high confidence

Added translation helper framework for configurable string overrides

A new translation helper package has been introduced to allow users to override default application strings via environment variables or a JSON configuration file. The helper function checks for environment variables prefixed with GITHUB\MCP\ (e.g., GITHUB\_MCP\_KEY) and falls back to a JSON config file named github-mcp-server-config.json, enabling runtime customization of text without code changes. It also provides a mechanism to dump the resolved translation map back to the JSON file for persistence.

pkg/translations · high confidence

Automated documentation generation and OAuth scope listing commands

The server now includes a \generate-docs\ command that automatically updates the README, remote server documentation, and feature-flag/Insiders documentation sections by analyzing the current tool inventory and feature flags. It also adds a \list-scopes\ command that outputs the OAuth challenge scopes required by enabled tools in text, JSON, or summary formats. These changes improve transparency around tool capabilities and authentication requirements without altering the server's runtime behavior.

cmd/github-mcp-server · high confidence

Granular issue and pull request tool inputs with typed schema validation

The server now defines explicit input types for granular issue and pull request operations, introducing structured structs like GranularIssueCoordinate and GranularPullRequestCoordinate to replace heterogeneous or loosely-typed arguments. These new types are integrated into the inventory system, which now supports typed schema generation, input normalization, and per-call OAuth scope challenges, ensuring that tool arguments are validated against precise JSON schemas before execution.

github.com/github/github-mcp-server/v2 · high confidence

Introduce AppProvider, FeedbackFooter, and MarkdownEditor components

Added AppProvider to manage theme context (light/dark/auto) via Primer React's ThemeProvider and inject a FeedbackFooter link for MCP Apps insiders feedback. Added FeedbackFooter component displaying a link to the GitHub MCP Server issues page. Added MarkdownEditor component providing a rich text editing experience with toolbar buttons, preview mode, and list continuation logic, styled with Primer React and GitHub's markdown-toolbar-element.

ui/src/components · high confidence

Introduce Inventory pattern for tool, resource, and prompt management

The server now uses a new Inventory system in \pkg/inventory\ to manage tools, resources, and prompts. This system provides a builder-based API for configuring the server's capabilities, including support for toolsets, feature flags, and read-only modes. It introduces a \ForMCPRequest\ method that optimizes registration by only including items relevant to the specific MCP method being called (e.g., only the specific tool for \tools/call\), reducing overhead. The inventory also handles deterministic sorting of items and generates server instructions based on enabled toolsets.

pkg/inventory · high confidence

Introduce OAuth 2.0 Protected Resource Metadata support for HTTP mode

The HTTP server now implements RFC 9728 Protected Resource Metadata, advertising supported OAuth scopes and the authorization server URL at the \/.well-known/oauth-protected-resource\ path. This allows MCP clients to automatically discover the correct OAuth configuration. The implementation respects the \--gh-host\ (AuthorizationServer) configuration, defaults to GitHub's OAuth server, and includes a \TrustProxyHeaders\ option to safely handle \X-Forwarded-Host\ and \X-Forwarded-Proto\ headers when deployed behind a trusted proxy.

pkg/http/oauth · high confidence

Introduce content sanitization for titles and bodies

Added a new \pkg/sanitize\ package that cleans user-authored text to prevent rendering issues and security risks. The \Sanitize\ function processes content bodies by stripping invisible Unicode characters (such as zero-width spaces and BiDi controls), filtering code-fence metadata, and sanitizing HTML tags using the \bluemonday\ library. A separate \PlainText\ function handles titles and other plain-text surfaces by neutralizing angle brackets and nested HTML entities to ensure safe display without HTML interpretation.

pkg/sanitize · high confidence

Introduce mcpcurl CLI tool for dynamic MCP server interaction

A new command-line utility, \mcpcurl\, is added to the \cmd/mcpcurl\ directory. It connects to an MCP server via stdio, dynamically retrieves the available tool schemas, and generates corresponding CLI subcommands for execution. The tool supports parameter validation based on the server's schema, handles JSON-RPC error responses, and includes a \--pretty\ flag to format JSON/JSONL output. Installation instructions and usage examples are provided in the new README.

cmd/mcpcurl · high confidence

Introduces per-call OAuth scope enforcement and discovery

The \pkg/scopes\ package now provides the infrastructure for checking and resolving OAuth scopes on a per-tool-call basis. It includes a fetcher that retrieves the \X-OAuth-Scopes\ header from the GitHub API to discover a token's capabilities, a scope map that links tools to their required scope policies, and a hierarchy that allows parent scopes (like \repo\) to satisfy child requirements (like \public\_repo\). This enables the server to validate that a user's token has the necessary permissions for specific actions and to challenge for additional scopes when needed.

pkg/scopes · high confidence

New API host resolution and MCP tool result utilities in pkg/utils

This change introduces new utility packages in pkg/utils that enhance how the application connects to GitHub and handles Model Context Protocol (MCP) responses. The new api.go module provides a structured APIHostResolver that correctly resolves REST, GraphQL, upload, and raw file URLs for GitHub.com, GitHub Enterprise Cloud (GHEC), and GitHub Enterprise Server (GHES), including support for subdomain isolation and preserving loopback ports/IPv6 brackets. It also enforces HTTPS for remote GHEC/GHES hosts to prevent cleartext credential transmission, while allowing HTTP for local loopback addresses. Additionally, result.go adds helper functions for constructing MCP CallToolResult objects, including a new awaiting-form-submission result type that signals to agents that an interactive UI form is being shown and the operation has not yet been performed. The token.go module adds logic to parse and classify GitHub authorization tokens by their prefixes (personal access, fine-grained, OAuth, and GitHub App tokens).

pkg/utils · high confidence

New GitHub Actions, Code Quality, and Code Scanning tools

This change introduces new MCP tools for GitHub Actions, Code Quality, and Code Scanning. The \actions.go\ file adds a consolidated \actions\_list\ tool that supports multiple methods (e.g., \list\_workflows\, \list\_workflow\_runs\, \get\_workflow\_job\_logs\) and includes minimal response types to reduce payload size. The \code\_quality.go\ file adds a \get\_code\_quality\_finding\ tool to retrieve details of specific code quality findings. The \code\_scanning.go\ file adds \get\_code\_scanning\_alert\ and \list\_code\_scanning\_alerts\ tools for managing code scanning alerts, with appropriate security scopes and IFC labeling. Tests are provided for all new tools.

pkg/github · high confidence

New HTTP header constants and parsing utilities

This change introduces a new \pkg/http/headers\ package that centralizes standard HTTP header names (such as Authorization, Content-Type, ETag, and various X-Forwarded headers) alongside specific constants for MCP (Model Context Protocol) headers like Mcp-Method, Mcp-Name, and Mcp-Param-\*. It also adds a \ParseCommaSeparated\ utility function to safely split and trim comma-separated header values, along with corresponding unit tests for this parsing logic.

pkg/http/headers · high confidence

New HTTP transport layer with scoped auth, ETag caching, and GraphQL features

The HTTP transport package has been replaced with a modular set of RoundTripper implementations. BearerAuthTransport now scopes tokens to configured GitHub hosts to prevent credential leakage on redirects, and supports per-request token providers for OAuth flows. ETagTransport adds conditional GET support with a bounded LRU cache to reduce bandwidth and rate-limit usage for repeated requests. GraphQLFeaturesTransport injects feature headers from context to enable non-GA API capabilities, and UserAgentTransport standardizes the User-Agent header.

pkg/http/transport · high confidence

New MCP Apps for creating and editing issues and pull requests

This change introduces new UI applications for GitHub MCP tools, providing dedicated interfaces for creating and editing issues and pull requests. The \issue-write\ app allows users to compose issues with support for custom fields, labels, assignees, and milestones, while the \pr-write\ and \pr-edit\ apps provide forms for creating and modifying pull requests, including branch selection, reviewer management, and draft status. These apps integrate with the host environment via the \open-link\ capability to open created or edited items in the browser.

ui/src/apps/issue-write · high confidence

New MCP Server Card discovery endpoint

Added a new HTTP handler at /server-card that serves a static metadata document (Server Card) describing the GitHub MCP Server's identity, repository, and streamable-HTTP transport. This allows clients to discover and connect to the server before the protocol handshake, without requiring authentication. The endpoint supports content negotiation, ETag-based caching, and CORS, and is configurable for per-environment remote URLs.

pkg/http/servercard · high confidence

New PKCE and device-based OAuth 2.1 login flows for GitHub

The internal OAuth module now implements a multi-round-trip authorization flow using PKCE (with a local callback server) as the primary method, falling back to the device authorization flow when a local callback is unreachable (e.g., inside Docker or on headless systems). This change introduces a new callback server that binds to loopback by default, validates the OAuth state parameter to prevent CSRF, and renders success/error pages. It also adds environment detection for Docker and headless Linux sessions to automatically select the appropriate flow, and includes comprehensive tests for the callback handler, flow selection logic, and token refresh behavior.

internal/oauth · high confidence

New development and release utility scripts

This change introduces a suite of new shell scripts to streamline the development workflow and release process. The \script/build-ui\ script automates the installation and build of the MCP App UIs. A new \script/conformance-test\ script allows developers to compare server behavior between branches by building binaries, running MCP JSON-RPC list commands, and generating detailed diff reports. The \script/fetch-icons\ script downloads Octicon SVGs, converts them to PNGs for light and dark themes, and generates embedded data URIs. Release management is supported by \script/tag-release\, which handles semantic version validation, branch checks, and tag creation. Compliance is improved with \script/licenses\ and \script/licenses-check\, which generate architecture-specific license reports and verify they are up to date. Additional utilities include \script/generate-docs\ for server documentation, \script/list-scopes\ for OAuth scope analysis, \script/prettyprint-log\ for colored log visualization, and \script/lint\ for running golangci-lint. The \script/get-me\ script is updated to follow the MCP protocol's initialize/initialized handshake sequence.

script · high confidence

New internal GitHub GraphQL mock server for testing

The \internal/githubv4mock\ package has been added to provide a mock GraphQL server for testing queries and mutations against the \shurcooL/githubv4\ library. This utility allows tests to register matchers for specific GraphQL requests and return predefined responses, supporting both success and error scenarios. It includes logic to handle variable matching, including type coercion for numeric types and handling of typed nils, ensuring that test assertions accurately reflect the structure of GraphQL requests sent by the application.

internal/githubv4mock · high confidence

New useMcpApp hook for MCP Apps SDK v2 integration

The \ui/src/hooks\ directory now includes a new \useMcpApp\ hook that wraps the \@modelcontextprotocol/ext-apps\ SDK v2. This hook manages the lifecycle of MCP Apps, providing React state for tool results, tool inputs, and host context changes. It exposes methods for calling tools (\callTool\), updating the model context (\setModelContext\), and opening external links (\openLink\), with automatic resizing and strict mode support in development.

ui/src/hooks · high confidence

Removals

Removal of the cmd/server entry point

The main server entry point located at cmd/server/main.go has been removed from the codebase. This change eliminates the local implementation of the Cobra command-line interface, Viper configuration binding, and the stdio server startup logic that previously handled logging initialization and GitHub MCP server execution.

cmd/server · high confidence

Behavioural changes

Centralized request context for tokens, features, and MCP metadata

The \pkg/context\ package now provides a unified set of context helpers to carry request-specific state throughout the application. This includes authentication details (token info and scopes), feature flags (GraphQL, HTTP header-based, and UI support), operational modes (read-only, lockdown, insiders), and MCP-specific metadata (method info, toolsets, tools, and excluded tools). By storing these values in the context, the system avoids redundant parsing and enables downstream components to make decisions based on the current request's capabilities and constraints.

pkg/context · high confidence

GitHub MCP server tool definitions updated

The tool specification snapshots in \pkg/github/\_\toolsnaps\\_\ have been regenerated to reflect the current set of available GitHub MCP tools. This update includes new tools for managing GitHub Actions workflows (such as \actions\_get\, \actions\_list\, and \actions\_run\_trigger\), handling pull request reviews and comments (including \add\_comment\_to\_pending\_review\ and \add\_pull\_request\_review\_comment\), and managing issues with sub-issues and reactions. It also introduces governance capabilities via \create\_repository\_ruleset\ and \custom\_properties\_read/write\, as well as Copilot assignment tools (\assign\_copilot\_to\_issue\ and \assign\_copilot\_to\_issue\_with\_intent\). These changes ensure that the tool schemas, input parameters, and descriptions in this directory are synchronized with the latest server implementation.

pkg/github/\\toolsnaps\\_ · high confidence_

Improved handling of deferred tool results and standardized UI data parsing

The UI now correctly distinguishes between completed tool results and deferred states (where the server awaits user submission), preventing forms from rendering for actions already executed by the agent. Additionally, a new \parseUIGetResult\ utility standardizes the parsing of UI-related data (such as labels, assignees, and branches), ensuring consistent handling of both legacy and modern payload formats while explicitly validating response envelopes.

ui/src/lib · high confidence

Introduce new HTTP handler with configurable request limits and OAuth overrides

The HTTP server now uses a new handler implementation that enforces a configurable maximum request body size (defaulting to 5 MiB) to prevent oversized payloads before MCP parsing. It also supports overriding the OAuth authorization server URL via the --authorization-server flag, which is useful when deploying behind an OAuth proxy. Additionally, the handler validates static tool configurations at startup, failing immediately if invalid tools are specified, and includes a shared schema cache to reduce reflection overhead.

pkg/http · high confidence

Lockdown mode now uses per-identity cached repository access checks

The lockdown feature now caches repository access metadata (private status and push permissions) to improve performance, while ensuring that these checks are strictly isolated per user identity. The cache is scoped using a hashed identity digest so that decisions made under one user's credentials are never served to another, and entries expire after a default 20-minute TTL. Trusted bots like Copilot are excluded from these filtering checks.

pkg/lockdown · high confidence

New HTTP middleware layer for MCP request handling

The HTTP middleware package has been restructured with a new set of handlers that enforce a 5 MiB request body limit, configure CORS to allow browser-based MCP clients, parse MCP JSON-RPC envelopes early to enable tool filtering, extract and validate user tokens (including PATs and OAuth tokens), and enforce per-call OAuth scope challenges. Additionally, request configuration middleware now supports feature flags via both headers and URL query parameters, allowing dynamic feature selection for headerless hosted connections.

pkg/http/middleware · high confidence

OAuth authentication now uses multi-round-trip elicitation and scopes tokens to configured hosts

The server's OAuth flow has been upgraded to support multi-round-trip elicitation, allowing clients to present authorization prompts via URL or form modes and handle the response without blocking the main session. This change also ensures that authentication tokens are strictly scoped to the configured GitHub hosts, preventing them from being leaked to foreign hosts during redirects. Additionally, the server now supports GitHub App server-to-server authentication for stdio connections, enabling automated access without user interaction.

internal/ghmcp · high confidence

Octicons are now embedded as offline data URIs for faster, offline icon loading

The \pkg/octicons\ package now embeds Octicon PNGs directly as base64 data URIs (light and dark variants) instead of relying on external URLs. This change enables offline icon rendering and reduces load times for users. The \Icons\ function returns MCP Icon objects with these embedded sources, and the \Sizes\ field is intentionally omitted to maintain backward compatibility with older MCP clients.

pkg/octicons · high confidence

Structured GitHub error tracking with improved rate-limit messaging

The error handling layer now introduces dedicated error types (GitHubAPIError, GitHubGraphQLError, GitHubRawAPIError) and a context-based mechanism to accumulate and retrieve these errors across the request lifecycle. This allows middleware and downstream components to inspect detailed error information without relying solely on context propagation. Additionally, when a GitHub API rate limit is hit, the system now detects specific rate-limit errors and returns user-friendly messages that include the exact retry time or a generic wait instruction, rather than a generic failure message.

pkg/errors · high confidence

Unified UI build script for faster, portable builds

The UI build process now uses a single Node.js script (ui/scripts/build.mjs) to build all four applications (get-me, issue-write, pr-write, pr-edit) in one Vite process, replacing the previous serial invocations. This change reduces startup overhead by avoiding repeated Vite and plugin initialization for each app and removes the dependency on cross-env for environment variable handling, resulting in faster and more portable builds.

ui/scripts · high confidence

Test coverage

Added end-to-end test suite for the GitHub MCP Server; Added snapshot testing utility for tool JSON schemas.

Dependencies

Major dependency upgrades and Go module migration

The Go module has been migrated from \github.com/github/mcp-server-playground\ to \github.com/github/github-mcp-server\ and upgraded to Go 1.25.12. Key dependency updates include \google/go-github\ from v69 to v89, \modelcontextprotocol/go-sdk\ to v1.7.0, \go-chi/chi/v5\ to v5.3.2, \spf13/cobra\ to v1.10.2, \spf13/viper\ to v1.21.0, and \google/jsonschema-go\ to v0.4.3. The UI \package.json\ introduces \@modelcontextprotocol/ext-apps\ v1.7.2, \@primer/octicons-react\ v19.0.0, \react-markdown\ v10.1.0, and \remark-gfm\ v4.0.1, while upgrading build tools to Vite v8.0.16 and \@vitejs/plugin-react\ v6.0.2.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 53 → 54 (+0.4)
  • Rubric changed (rubric-2026.09.15 → rubric-2026.10.5) — scores are not directly comparable.

Lenses

  • Code Health 44 → 47 (+3.3)
  • Architecture 96 → 90 (-6.0)
  • Maturity 64 → 71 (+6.9)
  • Readiness 78 → 53 (-24.7)
  • Security 84 → 89 (+5.2)
  • Accessibility 48 → 50 (+2.0)
  • Performance 87 (new)

Resolved (284)

  • Dependency pinned to a stale untagged commit: github.com/shurcooL/graphql
  • Documentation: no installation or build instructions (README.md)
  • Duplicated block (10 lines × 17) (pkg/github/find_duplicate.go)
  • Duplicated block (10 lines × 2) (pkg/github/issues.go)
  • Duplicated block (10 lines × 2) (pkg/github/issues.go)
  • Duplicated block (10 lines × 2) (pkg/github/issues.go)
  • Duplicated block (10 lines × 2) (pkg/github/issues_granular.go)
  • Duplicated block (10 lines × 2) (pkg/github/notifications.go)
  • Duplicated block (10 lines × 2) (pkg/github/projects.go)
  • Duplicated block (10 lines × 2) (pkg/github/pullrequests.go)
  • Duplicated block (10 lines × 4) (pkg/github/discussions.go)
  • Duplicated block (10 lines × 4) (pkg/github/pullrequests.go)
  • Duplicated block (10 lines × 5) (pkg/github/issues.go)
  • Duplicated block (10–11 lines × 6) (pkg/github/actions.go)
  • Duplicated block (10–12 lines × 13) (pkg/github/copilot.go)
  • Duplicated block (11 lines × 2) (pkg/github/dependabot.go)
  • Duplicated block (11 lines × 2) (pkg/github/discussions.go)
  • Duplicated block (11 lines × 2) (pkg/github/issues.go)
  • Duplicated block (11 lines × 2) (pkg/github/issues.go)
  • Duplicated block (11 lines × 2) (pkg/github/issues_granular.go)
  • …and 264 more

New (212)

  • Duplicated block (10 lines × 2) (pkg/github/code_scanning.go)
  • Duplicated block (10 lines × 2) (pkg/github/code_scanning.go)
  • Duplicated block (10 lines × 2) (pkg/github/comment_minimize.go)
  • Duplicated block (10 lines × 2) (pkg/github/granular_issue_types.go)
  • Duplicated block (10 lines × 2) (pkg/github/notifications.go)
  • Duplicated block (10 lines × 2) (pkg/github/pullrequests.go)
  • Duplicated block (10 lines × 2) (pkg/github/repositories.go)
  • Duplicated block (10 lines × 2) (pkg/github/search.go)
  • Duplicated block (10 lines × 2) (pkg/github/secret_scanning.go)
  • Duplicated block (10 lines × 5) (pkg/github/discussions.go)
  • Duplicated block (10 lines × 5) (pkg/github/pullrequests.go)
  • Duplicated block (10 lines × 6) (pkg/github/pullrequests.go)
  • Duplicated block (11 lines × 2) (pkg/github/consolidated_issue_types.go)
  • Duplicated block (11 lines × 2) (pkg/github/discussions.go)
  • Duplicated block (11 lines × 2) (pkg/github/labels.go)
  • Duplicated block (11 lines × 2) (pkg/github/projects.go)
  • Duplicated block (11 lines × 2) (pkg/github/pullrequests.go)
  • Duplicated block (11 lines × 2) (pkg/github/pullrequests_granular.go)
  • Duplicated block (11 lines × 2) (pkg/github/repositories.go)
  • Duplicated block (11 lines × 2) (pkg/github/repositories.go)
  • …and 192 more

Changes since last survey

  • 33 commits — 30 feature/other, 3 fixes

By area

  • pkg/github — 23 commits
  • (root) — 3 commits
  • .github/workflows — 3 commits
  • pkg/inventory — 2 commits
  • cmd/github-mcp-server — 1 commit
  • ui/src — 1 commit

Notable commits

  • fix: fix(go)!: use the v2 module path for Go consumers (#3445)
  • fix: fix(inventory): retain typed tool header validation (#3454)
  • fix: fix(pull_request_reviews): Update pending pull request review lookup to work when the authenticated actor is a Copilot bot (#3355)
  • change: Add granular tools to hide and unhide issue comments, PR review comments and PR reviews (#3350)
  • change: Address typed output compatibility gaps (#3433)
  • change: Always enable MCP Apps UI; remove remote_mcp_ui_apps flag gate (#3348)
  • change: Pin GitHub Actions to commit SHAs (#3259)
  • change: Preserve versioned STDIO API user agents across MCP protocols (#3323)
  • change: Type granular issue MCP inputs and protocol-gated outputs (#3394)
  • change: Use source revisions for non-release Docker builds (#3357)
  • change: build(deps): remediate npm alerts and refresh safe dependencies (#3370)
  • change: build(deps): upgrade go-github to v92.0.0 (#3381)
  • change: build(ui): migrate to React 19 and Primer React 38 (#3383)
  • change: build(ui): upgrade TypeScript 7 and align Node 26 toolchain (#3379)
  • change: build: upgrade golangci-lint to v2.14.0 (#3380)
  • change: ci(mcp-diff): prebuild HTTP server and fail when a side is unreachable (#3440)
  • change: ci: migrate cosign to v3 and dual-publish image signatures (#3382)
  • change: feat(comments): add typed visibility tool inputs and outputs (#3384)
  • change: feat(context): add typed tool schemas and outputs (#3377)
  • change: feat(inventory): add typed MCP tool registration foundation (#3371)
  • …and 13 more

Architecture

  • 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

github/github-mcp-server was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 10 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit eb47a99ddb866ca2b8a162920e6bda9521f33ebb — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer preprod-fe8540b5da9b.