package github

import (

"context"

"encoding/base64"

"encoding/json"

"fmt"

"io"

"net/http"

"strings"

ghErrors "github.com/github/github-mcp-server/pkg/errors"

"github.com/github/github-mcp-server/pkg/inventory"

"github.com/github/github-mcp-server/pkg/octicons"

"github.com/github/github-mcp-server/pkg/scopes"

"github.com/github/github-mcp-server/pkg/translations"

"github.com/github/github-mcp-server/pkg/utils"

"github.com/google/go-github/v82/github"

"github.com/google/jsonschema-go/jsonschema"

"github.com/modelcontextprotocol/go-sdk/mcp"

)

func GetCommit(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataRepos,

mcp.Tool{

Name: "get_commit",

Description: t("TOOL_GET_COMMITS_DESCRIPTION", "Get details for a commit from a GitHub repository"),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_GET_COMMITS_USER_TITLE", "Get commit details"),

ReadOnlyHint: true,

},

InputSchema: WithPagination(&jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"sha": {

Type: "string",

Description: "Commit SHA, branch name, or tag name",

},

"include_diff": {

Type: "boolean",

Description: "Whether to include file diffs and stats in the response. Default is true.",

Default: json.RawMessage(`true`),

},

},

Required: []string{"owner", "repo", "sha"},

}),

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

sha, err := RequiredParam[string](args, "sha")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

includeDiff, err := OptionalBoolParamWithDefault(args, "include_diff", true)

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

pagination, err := OptionalPaginationParams(args)

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

opts := &github.ListOptions{

Page: pagination.Page,

PerPage: pagination.PerPage,

}

client, err := deps.GetClient(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get GitHub client: %w", err)

}

commit, resp, err := client.Repositories.GetCommit(ctx, owner, repo, sha, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

fmt.Sprintf("failed to get commit: %s", sha),

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != 200 {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get commit", resp, body), nil, nil

}

// Convert to minimal commit

minimalCommit := convertToMinimalCommit(commit, includeDiff)

r, err := json.Marshal(minimalCommit)

if err != nil {

return nil, nil, fmt.Errorf("failed to marshal response: %w", err)

}

return utils.NewToolResultText(string(r)), nil, nil

},

)

}

// ListCommits creates a tool to get commits of a branch in a repository.

func ListCommits(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataRepos,

mcp.Tool{

Name: "list_commits",

Description: t("TOOL_LIST_COMMITS_DESCRIPTION", "Get list of commits of a branch in a GitHub repository. Returns at least 30 results per page by default, but can return more if specified using the perPage parameter (up to 100)."),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_LIST_COMMITS_USER_TITLE", "List commits"),

ReadOnlyHint: true,

},

InputSchema: WithPagination(&jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"sha": {

Type: "string",

Description: "Commit SHA, branch or tag name to list commits of. If not provided, uses the default branch of the repository. If a commit SHA is provided, will list commits up to that SHA.",

},

"author": {

Type: "string",

Description: "Author username or email address to filter commits by",

},

"path": {

Type: "string",

Description: "Only commits containing this file path will be returned",

},

"since": {

Type: "string",

Description: "Only commits after this date will be returned (ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ or YYYY-MM-DD)",

},

"until": {

Type: "string",

Description: "Only commits before this date will be returned (ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ or YYYY-MM-DD)",

},

},

Required: []string{"owner", "repo"},

}),

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

sha, err := OptionalParam[string](args, "sha")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

author, err := OptionalParam[string](args, "author")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

path, err := OptionalParam[string](args, "path")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

sinceStr, err := OptionalParam[string](args, "since")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

untilStr, err := OptionalParam[string](args, "until")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

pagination, err := OptionalPaginationParams(args)

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

// Set default perPage to 30 if not provided

perPage := pagination.PerPage

if perPage == 0 {

perPage = 30

}

opts := &github.CommitsListOptions{

SHA: sha,

Path: path,

Author: author,

ListOptions: github.ListOptions{

Page: pagination.Page,

PerPage: perPage,

},

}

if sinceStr != "" {

sinceTime, err := parseISOTimestamp(sinceStr)

if err != nil {

return utils.NewToolResultError(fmt.Sprintf("invalid since timestamp: %s", err)), nil, nil

}

opts.Since = sinceTime

}

if untilStr != "" {

untilTime, err := parseISOTimestamp(untilStr)

if err != nil {

return utils.NewToolResultError(fmt.Sprintf("invalid until timestamp: %s", err)), nil, nil

}

opts.Until = untilTime

}

client, err := deps.GetClient(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get GitHub client: %w", err)

}

commits, resp, err := client.Repositories.ListCommits(ctx, owner, repo, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

fmt.Sprintf("failed to list commits: %s", sha),

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != 200 {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to list commits", resp, body), nil, nil

}

// Convert to minimal commits

minimalCommits := make([]MinimalCommit, len(commits))

for i, commit := range commits {

minimalCommits[i] = convertToMinimalCommit(commit, false)

}

r, err := json.Marshal(minimalCommits)

if err != nil {

return nil, nil, fmt.Errorf("failed to marshal response: %w", err)

}

return utils.NewToolResultText(string(r)), nil, nil

},

)

}

// ListBranches creates a tool to list branches in a GitHub repository.

func ListBranches(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataRepos,

mcp.Tool{

Name: "list_branches",

Description: t("TOOL_LIST_BRANCHES_DESCRIPTION", "List branches in a GitHub repository"),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_LIST_BRANCHES_USER_TITLE", "List branches"),

ReadOnlyHint: true,

},

InputSchema: WithPagination(&jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner",

},

"repo": {

Type: "string",

Description: "Repository name",

},

},

Required: []string{"owner", "repo"},

}),

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

pagination, err := OptionalPaginationParams(args)

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

opts := &github.BranchListOptions{

ListOptions: github.ListOptions{

Page: pagination.Page,

PerPage: pagination.PerPage,

},

}

client, err := deps.GetClient(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get GitHub client: %w", err)

}

branches, resp, err := client.Repositories.ListBranches(ctx, owner, repo, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to list branches",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to list branches", resp, body), nil, nil

}

// Convert to minimal branches

minimalBranches := make([]MinimalBranch, 0, len(branches))

for _, branch := range branches {

minimalBranches = append(minimalBranches, convertToMinimalBranch(branch))

}

r, err := json.Marshal(minimalBranches)

if err != nil {

return nil, nil, fmt.Errorf("failed to marshal response: %w", err)

}

return utils.NewToolResultText(string(r)), nil, nil

},

)

}

// CreateOrUpdateFile creates a tool to create or update a file in a GitHub repository.

func CreateOrUpdateFile(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataRepos,

mcp.Tool{

Name: "create_or_update_file",

Description: t("TOOL_CREATE_OR_UPDATE_FILE_DESCRIPTION", `Create or update a single file in a GitHub repository.

If updating, you should provide the SHA of the file you want to update. Use this tool to create or update a file in a GitHub repository remotely; do not use it for local file operations.

In order to obtain the SHA of original file version before updating, use the following git command:

git rev-parse <branch>:<path to file>

SHA MUST be provided for existing file updates.

`),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_CREATE_OR_UPDATE_FILE_USER_TITLE", "Create or update file"),

ReadOnlyHint: false,

},

InputSchema: &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner (username or organization)",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"path": {

Type: "string",

Description: "Path where to create/update the file",

},

"content": {

Type: "string",

Description: "Content of the file",

},

"message": {

Type: "string",

Description: "Commit message",

},

"branch": {

Type: "string",

Description: "Branch to create/update the file in",

},

"sha": {

Type: "string",

Description: "The blob SHA of the file being replaced. Required if the file already exists.",

},

},

Required: []string{"owner", "repo", "path", "content", "message", "branch"},

},

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

path, err := RequiredParam[string](args, "path")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

content, err := RequiredParam[string](args, "content")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

message, err := RequiredParam[string](args, "message")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

branch, err := RequiredParam[string](args, "branch")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

// json.Marshal encodes byte arrays with base64, which is required for the API.

contentBytes := []byte(content)

// Create the file options

opts := &github.RepositoryContentFileOptions{

Message: github.Ptr(message),

Content: contentBytes,

Branch: github.Ptr(branch),

}

// If SHA is provided, set it (for updates)

sha, err := OptionalParam[string](args, "sha")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

if sha != "" {

opts.SHA = github.Ptr(sha)

}

// Create or update the file

client, err := deps.GetClient(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get GitHub client: %w", err)

}

path = strings.TrimPrefix(path, "/")

// SHA validation using Contents API to fetch current file metadata (blob SHA)

getOpts := &github.RepositoryContentGetOptions{Ref: branch}

if sha != "" {

// User provided SHA - validate it's still current

existingFile, dirContent, respCheck, getErr := client.Repositories.GetContents(ctx, owner, repo, path, getOpts)

if respCheck != nil {

_ = respCheck.Body.Close()

}

switch {

case getErr != nil:

// 404 means file doesn't exist - proceed (new file creation)

// Any other error (403, 500, network) should be surfaced

if respCheck == nil || respCheck.StatusCode != http.StatusNotFound {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to verify file SHA",

respCheck,

getErr,

), nil, nil

}

case dirContent != nil:

return utils.NewToolResultError(fmt.Sprintf(

"Path %s is a directory, not a file. This tool only works with files.",

path)), nil, nil

case existingFile != nil:

currentSHA := existingFile.GetSHA()

if currentSHA != sha {

return utils.NewToolResultError(fmt.Sprintf(

"SHA mismatch: provided SHA %s is stale. Current file SHA is %s. "+

"Pull the latest changes and use git rev-parse %s:%s to get the current SHA.",

sha, currentSHA, branch, path)), nil, nil

}

}

} else {

// No SHA provided - check if file already exists

existingFile, dirContent, respCheck, getErr := client.Repositories.GetContents(ctx, owner, repo, path, getOpts)

if respCheck != nil {

_ = respCheck.Body.Close()

}

switch {

case getErr != nil:

// 404 means file doesn't exist - proceed with creation

// Any other error (403, 500, network) should be surfaced

if respCheck == nil || respCheck.StatusCode != http.StatusNotFound {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to check if file exists",

respCheck,

getErr,

), nil, nil

}

case dirContent != nil:

return utils.NewToolResultError(fmt.Sprintf(

"Path %s is a directory, not a file. This tool only works with files.",

path)), nil, nil

case existingFile != nil:

// File exists but no SHA was provided - reject to prevent blind overwrites

return utils.NewToolResultError(fmt.Sprintf(

"File already exists at %s. You must provide the current file's SHA when updating. "+

"Use git rev-parse %s:%s to get the blob SHA, then retry with the sha parameter.",

path, branch, path)), nil, nil

}

// If file not found, no previous SHA needed (new file creation)

}

fileContent, resp, err := client.Repositories.CreateFile(ctx, owner, repo, path, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to create/update file",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != 200 && resp.StatusCode != 201 {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to create/update file", resp, body), nil, nil

}

minimalResponse := convertToMinimalFileContentResponse(fileContent)

return MarshalledTextResult(minimalResponse), nil, nil

},

)

}

// CreateRepository creates a tool to create a new GitHub repository.

func CreateRepository(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataRepos,

mcp.Tool{

Name: "create_repository",

Description: t("TOOL_CREATE_REPOSITORY_DESCRIPTION", "Create a new GitHub repository in your account or specified organization"),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_CREATE_REPOSITORY_USER_TITLE", "Create repository"),

ReadOnlyHint: false,

},

InputSchema: &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"name": {

Type: "string",

Description: "Repository name",

},

"description": {

Type: "string",

Description: "Repository description",

},

"organization": {

Type: "string",

Description: "Organization to create the repository in (omit to create in your personal account)",

},

"private": {

Type: "boolean",

Description: "Whether repo should be private",

},

"autoInit": {

Type: "boolean",

Description: "Initialize with README",

},

},

Required: []string{"name"},

},

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

name, err := RequiredParam[string](args, "name")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

description, err := OptionalParam[string](args, "description")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

organization, err := OptionalParam[string](args, "organization")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

private, err := OptionalParam[bool](args, "private")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

autoInit, err := OptionalParam[bool](args, "autoInit")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo := &github.Repository{

Name: github.Ptr(name),

Description: github.Ptr(description),

Private: github.Ptr(private),

AutoInit: github.Ptr(autoInit),

}

client, err := deps.GetClient(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get GitHub client: %w", err)

}

createdRepo, resp, err := client.Repositories.Create(ctx, organization, repo)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to create repository",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusCreated {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to create repository", resp, body), nil, nil

}

// Return minimal response with just essential information

minimalResponse := MinimalResponse{

ID: fmt.Sprintf("%d", createdRepo.GetID()),

URL: createdRepo.GetHTMLURL(),

}

r, err := json.Marshal(minimalResponse)

if err != nil {

return nil, nil, fmt.Errorf("failed to marshal response: %w", err)

}

return utils.NewToolResultText(string(r)), nil, nil

},

)

}

// GetFileContents creates a tool to get the contents of a file or directory from a GitHub repository.

func GetFileContents(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataRepos,

mcp.Tool{

Name: "get_file_contents",

Description: t("TOOL_GET_FILE_CONTENTS_DESCRIPTION", "Get the contents of a file or directory from a GitHub repository"),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_GET_FILE_CONTENTS_USER_TITLE", "Get file or directory contents"),

ReadOnlyHint: true,

},

InputSchema: &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner (username or organization)",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"path": {

Type: "string",

Description: "Path to file/directory",

Default: json.RawMessage(`"/"`),

},

"ref": {

Type: "string",

Description: "Accepts optional git refs such as `refs/tags/{tag}`, `refs/heads/{branch}` or `refs/pull/{pr_number}/head`",

},

"sha": {

Type: "string",

Description: "Accepts optional commit SHA. If specified, it will be used instead of ref",

},

},

Required: []string{"owner", "repo"},

},

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

path, err := OptionalParam[string](args, "path")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

path = strings.TrimPrefix(path, "/")

ref, err := OptionalParam[string](args, "ref")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

originalRef := ref

sha, err := OptionalParam[string](args, "sha")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

client, err := deps.GetClient(ctx)

if err != nil {

return utils.NewToolResultError("failed to get GitHub client"), nil, nil

}

rawOpts, fallbackUsed, err := resolveGitReference(ctx, client, owner, repo, ref, sha)

if err != nil {

return utils.NewToolResultError(fmt.Sprintf("failed to resolve git reference: %s", err)), nil, nil

}

if rawOpts.SHA != "" {

ref = rawOpts.SHA

}

var fileSHA string

opts := &github.RepositoryContentGetOptions{Ref: ref}

// Always call GitHub Contents API first to get metadata including SHA and determine if it's a file or directory

fileContent, dirContent, respContents, err := client.Repositories.GetContents(ctx, owner, repo, path, opts)

if respContents != nil {

defer func() { _ = respContents.Body.Close() }()

}

// The path does not point to a file or directory.

// Instead let's try to find it in the Git Tree by matching the end of the path.

if err != nil || (fileContent == nil && dirContent == nil) {

return matchFiles(ctx, client, owner, repo, ref, path, rawOpts, 0)

}

if fileContent != nil && fileContent.SHA != nil {

fileSHA = *fileContent.SHA

fileSize := fileContent.GetSize()

// Build resource URI for the file using URI templates

pathParts := strings.Split(path, "/")

resourceURI, err := expandRepoResourceURI(owner, repo, sha, ref, pathParts)

if err != nil {

return utils.NewToolResultError("failed to build resource URI"), nil, nil

}

// main branch ref passed in ref parameter but it doesn't exist - default branch was used

var successNote string

if fallbackUsed {

successNote = fmt.Sprintf(" Note: the provided ref '%s' does not exist, default branch '%s' was used instead.", originalRef, rawOpts.Ref)

}

// Empty files (0 bytes) have no content to decode; return

// them directly as empty text to avoid errors from

// GetContent when the API returns null content with a

// base64 encoding field, and to avoid DetectContentType

// misclassifying them as binary.

if fileSize == 0 {

result := &mcp.ResourceContents{

URI: resourceURI,

Text: "",

MIMEType: "text/plain",

}

return utils.NewToolResultResource(fmt.Sprintf("successfully downloaded empty file (SHA: %s)%s", fileSHA, successNote), result), nil, nil

}

// For files >= 1MB, return a ResourceLink instead of content

const maxContentSize = 1024 * 1024 // 1MB

if fileSize >= maxContentSize {

size := int64(fileSize)

resourceLink := &mcp.ResourceLink{

URI: resourceURI,

Name: fileContent.GetName(),

Title: fmt.Sprintf("File: %s", path),

Size: &size,

}

return utils.NewToolResultResourceLink(

fmt.Sprintf("File %s is too large to display (%d bytes). Use the download URL to fetch the content: %s (SHA: %s)%s",

path, fileSize, fileContent.GetDownloadURL(), fileSHA, successNote),

resourceLink), nil, nil

}

// For files < 1MB, get content directly from Contents API

content, err := fileContent.GetContent()

if err != nil {

return utils.NewToolResultError(fmt.Sprintf("failed to decode file content: %s", err)), nil, nil

}

// Detect content type from the actual content bytes,

// mirroring the original approach of using the Content-Type header

// from the raw API response.

contentBytes := []byte(content)

contentType := http.DetectContentType(contentBytes)

// Determine if content is text or binary based on detected content type

isTextContent := strings.HasPrefix(contentType, "text/") ||

contentType == "application/json" ||

contentType == "application/xml" ||

strings.HasSuffix(contentType, "+json") ||

strings.HasSuffix(contentType, "+xml")

if isTextContent {

result := &mcp.ResourceContents{

URI: resourceURI,

Text: content,

MIMEType: contentType,

}

return utils.NewToolResultResource(fmt.Sprintf("successfully downloaded text file (SHA: %s)%s", fileSHA, successNote), result), nil, nil

}

// Binary content - encode as base64 blob

blobContent := base64.StdEncoding.EncodeToString(contentBytes)

result := &mcp.ResourceContents{

URI: resourceURI,

Blob: []byte(blobContent),

MIMEType: contentType,

}

return utils.NewToolResultResource(fmt.Sprintf("successfully downloaded binary file (SHA: %s)%s", fileSHA, successNote), result), nil, nil

} else if dirContent != nil {

// file content or file SHA is nil which means it's a directory

r, err := json.Marshal(dirContent)

if err != nil {

return utils.NewToolResultError("failed to marshal response"), nil, nil

}

return utils.NewToolResultText(string(r)), nil, nil

}

return utils.NewToolResultError("failed to get file contents"), nil, nil

},

)

}

// ForkRepository creates a tool to fork a repository.

func ForkRepository(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataRepos,

mcp.Tool{

Name: "fork_repository",

Description: t("TOOL_FORK_REPOSITORY_DESCRIPTION", "Fork a GitHub repository to your account or specified organization"),

Icons: octicons.Icons("repo-forked"),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_FORK_REPOSITORY_USER_TITLE", "Fork repository"),

ReadOnlyHint: false,

},

InputSchema: &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"organization": {

Type: "string",

Description: "Organization to fork to",

},

},

Required: []string{"owner", "repo"},

},

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

org, err := OptionalParam[string](args, "organization")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

opts := &github.RepositoryCreateForkOptions{}

if org != "" {

opts.Organization = org

}

client, err := deps.GetClient(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get GitHub client: %w", err)

}

forkedRepo, resp, err := client.Repositories.CreateFork(ctx, owner, repo, opts)

if err != nil {

// Check if it's an acceptedError. An acceptedError indicates that the update is in progress,

// and it's not a real error.

if resp != nil && resp.StatusCode == http.StatusAccepted && isAcceptedError(err) {

return utils.NewToolResultText("Fork is in progress"), nil, nil

}

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to fork repository",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusAccepted {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to fork repository", resp, body), nil, nil

}

// Return minimal response with just essential information

minimalResponse := MinimalResponse{

ID: fmt.Sprintf("%d", forkedRepo.GetID()),

URL: forkedRepo.GetHTMLURL(),

}

r, err := json.Marshal(minimalResponse)

if err != nil {

return nil, nil, fmt.Errorf("failed to marshal response: %w", err)

}

return utils.NewToolResultText(string(r)), nil, nil

},

)

}

// DeleteFile creates a tool to delete a file in a GitHub repository.

// This tool uses a more roundabout way of deleting a file than just using the client.Repositories.DeleteFile.

// This is because REST file deletion endpoint (and client.Repositories.DeleteFile) don't add commit signing to the deletion commit,

// unlike how the endpoint backing the create_or_update_files tool does. This appears to be a quirk of the API.

// The approach implemented here gets automatic commit signing when used with either the github-actions user or as an app,

// both of which suit an LLM well.

func DeleteFile(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataRepos,

mcp.Tool{

Name: "delete_file",

Description: t("TOOL_DELETE_FILE_DESCRIPTION", "Delete a file from a GitHub repository"),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_DELETE_FILE_USER_TITLE", "Delete file"),

ReadOnlyHint: false,

DestructiveHint: github.Ptr(true),

},

InputSchema: &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner (username or organization)",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"path": {

Type: "string",

Description: "Path to the file to delete",

},

"message": {

Type: "string",

Description: "Commit message",

},

"branch": {

Type: "string",

Description: "Branch to delete the file from",

},

},

Required: []string{"owner", "repo", "path", "message", "branch"},

},

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

path, err := RequiredParam[string](args, "path")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

message, err := RequiredParam[string](args, "message")