feat: add skill:// resource templates for Agent Skills discovery

Add MCP resource templates that expose Agent Skills (per agentskills.io
spec) from GitHub repositories via the skill:// URI scheme.

Resource templates:
- skill://{owner}/{repo}/{skill_name}/SKILL.md — fetch skill content
- skill://{owner}/{repo}/{skill_name}/_manifest — JSON manifest with
  repo:// URIs for each file, composing with existing repo:// resources

Discovery uses the Git Trees API to find SKILL.md files under known
paths (.github/skills/, skills/, .copilot/skills/).

Completions support for owner, repo (reusing existing resolvers), and
skill_name (discovers skills via tree search).

Registered under a new non-default 'skills' toolset. Enable with
--toolsets=skills or --toolsets=default,skills.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SamMorrowDrums

pkg/github/resources.go

@@ -15,5 +15,9 @@ func AllResources(t translations.TranslationHelperFunc) []inventory.ServerResour
 		GetRepositoryResourceCommitContent(t),
 		GetRepositoryResourceTagContent(t),
 		GetRepositoryResourcePrContent(t),
+
+		// Skill resources
+		GetSkillResourceContent(t),
+		GetSkillResourceManifest(t),
 	}
 }

pkg/github/server.go

@@ -200,6 +200,9 @@ func CompletionsHandler(getClient GetClientFn) func(ctx context.Context, req *mc
 			if strings.HasPrefix(req.Params.Ref.URI, "repo://") {
 				return RepositoryResourceCompletionHandler(getClient)(ctx, req)
 			}
+			if strings.HasPrefix(req.Params.Ref.URI, "skill://") {
+				return SkillResourceCompletionHandler(getClient)(ctx, req)
+			}
 			return nil, fmt.Errorf("unsupported resource URI: %s", req.Params.Ref.URI)
 		case "ref/prompt":
 			return nil, nil

pkg/github/skills_resource.go

@@ -0,0 +1,361 @@
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path"
+	"strings"
+
+	"github.com/github/github-mcp-server/pkg/inventory"
+	"github.com/github/github-mcp-server/pkg/octicons"
+	"github.com/github/github-mcp-server/pkg/translations"
+	gogithub "github.com/google/go-github/v82/github"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+	"github.com/yosida95/uritemplate/v3"
+)
+
+// skillSearchPaths are the directory prefixes where SKILL.md files are expected
+// per the Agent Skills specification (agentskills.io).
+var skillSearchPaths = []string{".github/skills/", "skills/", ".copilot/skills/"}
+
+var (
+	skillResourceContentURITemplate  = uritemplate.MustNew("skill://{owner}/{repo}/{skill_name}/SKILL.md")
+	skillResourceManifestURITemplate = uritemplate.MustNew("skill://{owner}/{repo}/{skill_name}/_manifest")
+)
+
+// GetSkillResourceContent defines the resource template for reading a skill's SKILL.md.
+func GetSkillResourceContent(t translations.TranslationHelperFunc) inventory.ServerResourceTemplate {
+	return inventory.NewServerResourceTemplate(
+		ToolsetMetadataSkills,
+		mcp.ResourceTemplate{
+			Name:        "skill_content",
+			URITemplate: skillResourceContentURITemplate.Raw(),
+			Description: t("RESOURCE_SKILL_CONTENT_DESCRIPTION", "Agent Skill instructions (SKILL.md) from a GitHub repository"),
+			Icons:       octicons.Icons("light-bulb"),
+		},
+		skillResourceContentHandlerFunc(skillResourceContentURITemplate),
+	)
+}
+
+// GetSkillResourceManifest defines the resource template for a skill's file manifest.
+func GetSkillResourceManifest(t translations.TranslationHelperFunc) inventory.ServerResourceTemplate {
+	return inventory.NewServerResourceTemplate(
+		ToolsetMetadataSkills,
+		mcp.ResourceTemplate{
+			Name:        "skill_manifest",
+			URITemplate: skillResourceManifestURITemplate.Raw(),
+			Description: t("RESOURCE_SKILL_MANIFEST_DESCRIPTION", "File manifest for an Agent Skill in a GitHub repository"),
+			Icons:       octicons.Icons("light-bulb"),
+		},
+		skillResourceManifestHandlerFunc(skillResourceManifestURITemplate),
+	)
+}
+
+func skillResourceContentHandlerFunc(tmpl *uritemplate.Template) inventory.ResourceHandlerFunc {
+	return func(_ any) mcp.ResourceHandler {
+		return skillContentHandler(tmpl)
+	}
+}
+
+func skillResourceManifestHandlerFunc(tmpl *uritemplate.Template) inventory.ResourceHandlerFunc {
+	return func(_ any) mcp.ResourceHandler {
+		return skillManifestHandler(tmpl)
+	}
+}
+
+// skillContentHandler returns a handler that fetches a skill's SKILL.md content.
+func skillContentHandler(tmpl *uritemplate.Template) mcp.ResourceHandler {
+	return func(ctx context.Context, request *mcp.ReadResourceRequest) (*mcp.ReadResourceResult, error) {
+		deps := MustDepsFromContext(ctx)
+		owner, repo, skillName, err := parseSkillURI(tmpl, request.Params.URI)
+		if err != nil {
+			return nil, err
+		}
+
+		client, err := deps.GetClient(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get GitHub client: %w", err)
+		}
+
+		skillDir, err := findSkillDir(ctx, client, owner, repo, skillName)
+		if err != nil {
+			return nil, err
+		}
+
+		skillMDPath := path.Join(skillDir, "SKILL.md")
+		fileContent, _, _, err := client.Repositories.GetContents(ctx, owner, repo, skillMDPath, nil)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get SKILL.md: %w", err)
+		}
+
+		content, err := fileContent.GetContent()
+		if err != nil {
+			return nil, fmt.Errorf("failed to decode SKILL.md content: %w", err)
+		}
+
+		return &mcp.ReadResourceResult{
+			Contents: []*mcp.ResourceContents{
+				{
+					URI:      request.Params.URI,
+					MIMEType: "text/markdown",
+					Text:     content,
+				},
+			},
+		}, nil
+	}
+}
+
+// SkillManifestEntry represents a single file in a skill's manifest.
+type SkillManifestEntry struct {
+	Path string `json:"path"`
+	URI  string `json:"uri"`
+	Size int    `json:"size"`
+}
+
+// SkillManifest represents the file listing for a skill directory.
+type SkillManifest struct {
+	Skill string               `json:"skill"`
+	Files []SkillManifestEntry `json:"files"`
+}
+
+// skillManifestHandler returns a handler that lists files in a skill directory.
+func skillManifestHandler(tmpl *uritemplate.Template) mcp.ResourceHandler {
+	return func(ctx context.Context, request *mcp.ReadResourceRequest) (*mcp.ReadResourceResult, error) {
+		deps := MustDepsFromContext(ctx)
+		owner, repo, skillName, err := parseSkillURI(tmpl, request.Params.URI)
+		if err != nil {
+			return nil, err
+		}
+
+		client, err := deps.GetClient(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get GitHub client: %w", err)
+		}
+
+		skillDir, err := findSkillDir(ctx, client, owner, repo, skillName)
+		if err != nil {
+			return nil, err
+		}
+
+		// Use recursive tree from repo root and filter to the skill directory
+		tree, _, err := client.Git.GetTree(ctx, owner, repo, "HEAD", true)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get repository tree: %w", err)
+		}
+
+		prefix := skillDir + "/"
+		manifest := SkillManifest{
+			Skill: skillName,
+			Files: make([]SkillManifestEntry, 0),
+		}
+		for _, entry := range tree.Entries {
+			if entry.GetType() != "blob" {
+				continue
+			}
+			entryPath := entry.GetPath()
+			if !strings.HasPrefix(entryPath, prefix) {
+				continue
+			}
+			relativePath := strings.TrimPrefix(entryPath, prefix)
+			pathParts := strings.Split(entryPath, "/")
+			repoURI, err := expandRepoResourceURI(owner, repo, "", "", pathParts)
+			if err != nil {
+				continue
+			}
+			manifest.Files = append(manifest.Files, SkillManifestEntry{
+				Path: relativePath,
+				URI:  repoURI,
+				Size: entry.GetSize(),
+			})
+		}
+
+		data, err := json.Marshal(manifest)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal manifest: %w", err)
+		}
+
+		return &mcp.ReadResourceResult{
+			Contents: []*mcp.ResourceContents{
+				{
+					URI:      request.Params.URI,
+					MIMEType: "application/json",
+					Text:     string(data),
+				},
+			},
+		}, nil
+	}
+}
+
+// parseSkillURI extracts owner, repo, and skill_name from a skill:// URI.
+func parseSkillURI(tmpl *uritemplate.Template, uri string) (owner, repo, skillName string, err error) {
+	values := tmpl.Match(uri)
+	if values == nil {
+		return "", "", "", fmt.Errorf("failed to match skill URI: %s", uri)
+	}
+
+	owner = values.Get("owner").String()
+	repo = values.Get("repo").String()
+	skillName = values.Get("skill_name").String()
+
+	if owner == "" {
+		return "", "", "", errors.New("owner is required")
+	}
+	if repo == "" {
+		return "", "", "", errors.New("repo is required")
+	}
+	if skillName == "" {
+		return "", "", "", errors.New("skill_name is required")
+	}
+
+	return owner, repo, skillName, nil
+}
+
+// findSkillDir locates the directory for a named skill within a repository.
+// It searches the known skill directory prefixes for a directory matching the skill name
+// that contains a SKILL.md file.
+func findSkillDir(ctx context.Context, client *gogithub.Client, owner, repo, skillName string) (string, error) {
+	for _, prefix := range skillSearchPaths {
+		candidatePath := prefix + skillName + "/SKILL.md"
+		_, _, resp, err := client.Repositories.GetContents(ctx, owner, repo, candidatePath, nil)
+		if err == nil {
+			return prefix + skillName, nil
+		}
+		if resp != nil && resp.StatusCode == 404 {
+			continue
+		}
+		if err != nil {
+			return "", fmt.Errorf("failed checking for skill at %s: %w", candidatePath, err)
+		}
+	}
+	return "", fmt.Errorf("skill %q not found in repository %s/%s", skillName, owner, repo)
+}
+
+// discoverSkills finds all skill directories in a repository by searching the tree
+// for directories containing SKILL.md files under the known skill search paths.
+func discoverSkills(ctx context.Context, client *gogithub.Client, owner, repo string) ([]string, error) {
+	tree, _, err := client.Git.GetTree(ctx, owner, repo, "HEAD", true)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get repository tree: %w", err)
+	}
+
+	seen := make(map[string]bool)
+	var skills []string
+
+	for _, entry := range tree.Entries {
+		if entry.GetType() != "blob" {
+			continue
+		}
+		entryPath := entry.GetPath()
+		if !strings.HasSuffix(entryPath, "/SKILL.md") {
+			continue
+		}
+
+		for _, prefix := range skillSearchPaths {
+			if !strings.HasPrefix(entryPath, prefix) {
+				continue
+			}
+			// Extract skill name: prefix + skillName + "/SKILL.md"
+			rest := strings.TrimPrefix(entryPath, prefix)
+			parts := strings.SplitN(rest, "/", 2)
+			if len(parts) == 2 && parts[1] == "SKILL.md" {
+				name := parts[0]
+				if !seen[name] {
+					seen[name] = true
+					skills = append(skills, name)
+				}
+			}
+		}
+	}
+
+	return skills, nil
+}
+
+// SkillResourceCompletionHandler handles completions for skill:// resource URIs.
+func SkillResourceCompletionHandler(getClient GetClientFn) func(ctx context.Context, req *mcp.CompleteRequest) (*mcp.CompleteResult, error) {
+	return func(ctx context.Context, req *mcp.CompleteRequest) (*mcp.CompleteResult, error) {
+		argName := req.Params.Argument.Name
+		argValue := req.Params.Argument.Value
+		var resolved map[string]string
+		if req.Params.Context != nil && req.Params.Context.Arguments != nil {
+			resolved = req.Params.Context.Arguments
+		} else {
+			resolved = map[string]string{}
+		}
+
+		// Reuse existing owner/repo resolvers
+		switch argName {
+		case "owner":
+			client, err := getClient(ctx)
+			if err != nil {
+				return nil, err
+			}
+			values, err := completeOwner(ctx, client, resolved, argValue)
+			if err != nil {
+				return nil, err
+			}
+			return completionResult(values), nil
+
+		case "repo":
+			client, err := getClient(ctx)
+			if err != nil {
+				return nil, err
+			}
+			values, err := completeRepo(ctx, client, resolved, argValue)
+			if err != nil {
+				return nil, err
+			}
+			return completionResult(values), nil
+
+		case "skill_name":
+			return completeSkillName(ctx, getClient, resolved, argValue)
+
+		default:
+			return nil, fmt.Errorf("no resolver for skill argument: %s", argName)
+		}
+	}
+}
+
+func completeSkillName(ctx context.Context, getClient GetClientFn, resolved map[string]string, argValue string) (*mcp.CompleteResult, error) {
+	owner := resolved["owner"]
+	repo := resolved["repo"]
+	if owner == "" || repo == "" {
+		return completionResult(nil), nil
+	}
+
+	client, err := getClient(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	skills, err := discoverSkills(ctx, client, owner, repo)
+	if err != nil {
+		return completionResult(nil), nil //nolint:nilerr // graceful degradation
+	}
+
+	if argValue != "" {
+		var filtered []string
+		for _, s := range skills {
+			if strings.HasPrefix(s, argValue) {
+				filtered = append(filtered, s)
+			}
+		}
+		skills = filtered
+	}
+
+	return completionResult(skills), nil
+}
+
+func completionResult(values []string) *mcp.CompleteResult {
+	if len(values) > 100 {
+		values = values[:100]
+	}
+	return &mcp.CompleteResult{
+		Completion: mcp.CompletionResultDetails{
+			Values:  values,
+			Total:   len(values),
+			HasMore: false,
+		},
+	}
+}