This repository is a curated collection of .gitignore file templates for a wide range of programming languages, frameworks, editors, and operating systems. It serves as the source for GitHub's built-in .gitignore template chooser when creating new repositories. The repository is organized into root-level templates for common technologies, a Global/ directory for editor/OS-specific rules, and a community/ directory for specialized or versioned templates. Each file is a self-contained list of file patterns to exclude from version control, following best practices for the respective technology. The templates are maintained through community contributions and a stale PR workflow. While the repository contains no executable code, its value lies in the curated, accurate, and up-to-date ignore rules that help developers avoid committing unnecessary or sensitive files.

This repository is the source of specify-cli, the flagship Python CLI of Spec Kit. In production it is a Typer-based developer tool that bootstraps projects for Spec-Driven Development: `specify init` scaffolds a `.specify/` structure, installs shared bash/PowerShell/Python helper scripts, and generates agent command/skill files into 37+ AI coding-tool directories (Claude, Copilot, Codex, Gemini, Cursor, Grok, Qwen, Tabnine, Goose, and more). Beyond scaffolding, the tool manages a layered ecosystem of extensions, presets, bundles, and YAML-defined workflows, plus a self-upgrade path that detects uv/pipx/uvx installations and pulls releases from the GitHub API.

This repository is the official community library for GitHub Copilot customizations, including agents, skills, instructions, plugins, canvas extensions, git hooks, and a cookbook of SDK recipes in multiple languages. It also hosts a production-quality React website (Astro + Primer Brand) that catalogs all resources with search, filters, and detail pages. The codebase is primarily a collection of markdown files, JavaScript/TypeScript modules, and Python scripts, organized into well-defined directories with validation tooling in `eng/`. While the website and some extensions (draw, pr-artifact-explorer, arcade games) demonstrate solid front-end architecture, the majority of content is declarative configuration and documentation. The repository is actively maintained with frequent commits and CI workflows, though the sheer volume of community contributions introduces inconsistency risks in skill structure and dependency pinning.

This repository implements a production-grade Model Context Protocol (MCP) server that exposes GitHub's REST and GraphQL APIs as a collection of tools, resources, and prompts for AI agents. The server runs in either stdio (local CLI) or HTTP (remote) mode, supporting multiple authentication methods: personal access tokens, OAuth 2.1 (PKCE browser flow, device flow, manual fallback), and GitHub App installation tokens. It provides over 90 fine-grained tools organized into toolsets (issues, pull requests, actions, projects, code scanning, etc.), each with metadata including required OAuth scopes, feature flags, read-only hints, and information flow control (IFC) labels. The architecture is modular: a central inventory builder registers all tools, resources, and prompts; per-request filtering narrows availability based on authentication, feature flags, toolsets, and read-only mode. The HTTP server uses a chi router with middleware for CORS, body limits, token extraction, scope challenge, and MCP method parsing. A React-based UI (Primer components) provides sandboxed forms for creating and editing issues and pull requests, served as embedded HTML resources. The server also includes lockdown mode for prompt injection mitigation, sanitization of user-authored content, field filtering to reduce response size, and telemetry for metrics collection. External dependencies include the MCP Go SDK, go-github (REST), shurcooL/githubv4 (GraphQL), and various utility libraries for OAuth, HTML sanitization, and configuration.

The GitHub Copilot SDK is a multi-language library development kit that enables developers to integrate GitHub Copilot's agentic workflows into their applications. It provides language-specific bindings (Java, .NET, Python, Go, Rust, Node.js) that communicate with the Copilot runtime via JSON-RPC over stdio, WebSocket, or in-memory (FFI) transports. The SDK manages session lifecycle, tool invocation, permission handling, and event processing, allowing host applications to leverage Copilot's AI capabilities for code assistance, chat, and agent-based tasks. The architecture centers around a CopilotClient class that handles connection establishment, session management, and message exchange. Key patterns include a transport abstraction layer for flexible communication, a code generation pipeline that ensures protocol consistency across languages, and extensibility points for defining custom tools and handling user permissions. The SDK supports advanced features such as Model Context Protocol (MCP) integration, custom agents, skills, and telemetry via OpenTelemetry. Code quality is maintained through schema-driven development, extensive unit and end-to-end testing, and clear marking of experimental APIs. The repository demonstrates strong engineering practices with reusable components like the JSON-RPC communication layer, session management patterns, and tool handling interfaces. While the multi-language nature increases maintenance overhead, the SDK remains actively updated with frequent releases and a focus on backward compatibility for stable APIs.

gh-stack is a GitHub CLI extension for managing stacked pull requests. It allows developers to create a stack of branches, each building on the previous one, and submit them as a chain of PRs. The tool handles rebasing, syncing, pushing, and merging the stack atomically, with both interactive TUI and non-interactive CLI modes. The architecture is a Go CLI built with Cobra, using Bubble Tea for interactive TUI components and lipgloss for styling. Git operations are abstracted behind an interface (internal/git/gitops.go) with mock support for testing. GitHub API integration is handled via go-gh, supporting GraphQL and REST endpoints for PR creation, stack management, and async merge. Local stack state is persisted as a JSON file in the git directory with optimistic concurrency and file locking. Key entry points include main.go calling cmd.Execute(), which registers all subcommands (init, add, submit, sync, rebase, push, merge, checkout, etc.). External dependencies include the GitHub CLI (gh), git, and the GitHub API. The codebase demonstrates strong engineering practices with extensive test coverage, interface-based mocking, and a modular internal package structure.

This repository is a distribution point for pre-built binaries of the CodeQL CLI, a static analysis tool for security vulnerabilities. It does not contain source code; instead, it provides release assets (zip files) and changelogs. The repository is primarily used for downloading the CLI and tracking releases. There is no code to analyze for craftsmanship or reusability.

This repository provides a custom HTML element, `<clipboard-copy>`, that copies text or element content to the clipboard when clicked. Implemented as a web component extending `HTMLElement`, it supports multiple data sources: the `value` attribute, a `for` attribute that references another element by ID (including inputs, textareas, and anchor hrefs), or element text content. The element ensures accessibility by automatically adding `role="button"` and `tabindex="0"` if not present, and handles keyboard events (Enter/Space) for activation. Internally, it uses the modern `navigator.clipboard.writeText()` API when available, falling back to `document.execCommand('copy')` via a temporary hidden node. It also normalizes Unicode whitespace characters (e.g., non-breaking spaces, zero-width joiners) to plain spaces or strips them, ensuring the copied text matches visual expectations. A `clipboard-copy` custom event is dispatched on success, allowing external handlers to provide feedback. The source code is written in TypeScript, is well-structured with clear separation of concerns (clipboard logic in `clipboard.ts`, element definition in `clipboard-copy-element.ts`, and a side-effect module for registration), and includes a comprehensive test suite covering element creation, clipboard operations, shadow DOM contexts, and edge cases like disabled state and Unicode normalization. The project follows GitHub's engineering standards (eslint, prettier, CI via GitHub Actions) and is published as an npm package under `@github/clipboard-copy-element`.

This repository is a sample GitHub App that demonstrates how to use webhooks with a GitHub App's installation token to create a bot that responds to pull request events. The application listens for `pull_request.opened` webhook events and automatically comments on the pull request with a predefined message from `message.md`. It is built with Node.js, uses the Octokit library for GitHub API interactions, and the `@octokit/webhooks` middleware to handle webhook verification and routing. The architecture is a simple HTTP server that exposes a `/api/webhook` endpoint. The code is straightforward and serves as a minimal example for developers to understand the basics of building a GitHub App. It includes environment variable configuration via dotenv, private key loading from file, and basic error handling. There are no tests, no complex data flows, and no reusable components beyond the pattern itself.