package github

import (

"context"

"encoding/json"

"errors"

"fmt"

"io"

"net/http"

"slices"

"strconv"

"strings"

"time"

ghcontext "github.com/github/github-mcp-server/v2/pkg/context"

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

"github.com/github/github-mcp-server/v2/pkg/ifc"

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

"github.com/github/github-mcp-server/v2/pkg/lockdown"

"github.com/github/github-mcp-server/v2/pkg/sanitize"

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

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

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

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

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

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

"github.com/shurcooL/githubv4"

)

// CloseIssueInput represents the input for closing an issue via the GraphQL API.

// Used to extend the functionality of the githubv4 library to support closing issues as duplicates.

type CloseIssueInput struct {

IssueID githubv4.ID `json:"issueId"`

ClientMutationID *githubv4.String `json:"clientMutationId,omitempty"`

StateReason *IssueClosedStateReason `json:"stateReason,omitempty"`

DuplicateIssueID *githubv4.ID `json:"duplicateIssueId,omitempty"`

}

// IssueClosedStateReason represents the reason an issue was closed.

// Used to extend the functionality of the githubv4 library to support closing issues as duplicates.

type IssueClosedStateReason string

// issueWriteFieldInput is a user-friendly issue field input for issue_write.

// Field IDs and option IDs are resolved internally before calling the REST API.

type issueWriteFieldInput struct {

FieldName string

Value any

FieldOptionName string

Delete bool

}

const (

IssueClosedStateReasonCompleted IssueClosedStateReason = "COMPLETED"

IssueClosedStateReasonDuplicate IssueClosedStateReason = "DUPLICATE"

IssueClosedStateReasonNotPlanned IssueClosedStateReason = "NOT_PLANNED"

)

// fetchIssueIDs retrieves issue IDs via the GraphQL API.

// When duplicateOf is 0, it fetches only the main issue ID.

// When duplicateOf is non-zero, it fetches both the main issue and duplicate issue IDs in a single query.

func fetchIssueIDs(ctx context.Context, gqlClient *githubv4.Client, owner, repo string, issueNumber int, duplicateOf int) (githubv4.ID, githubv4.ID, error) {

// Build query variables common to both cases

vars := map[string]any{

"owner": githubv4.String(owner),

"repo": githubv4.String(repo),

"issueNumber": githubv4.Int(issueNumber), // #nosec G115 - issue numbers are always small positive integers

}

if duplicateOf == 0 {

// Only fetch the main issue ID

var query struct {

Repository struct {

Issue struct {

ID githubv4.ID

} `graphql:"issue(number: $issueNumber)"`

} `graphql:"repository(owner: $owner, name: $repo)"`

}

if err := gqlClient.Query(ctx, &query, vars); err != nil {

return "", "", fmt.Errorf("failed to get issue ID: %w", err)

}

return query.Repository.Issue.ID, "", nil

}

// Fetch both issue IDs in a single query

var query struct {

Repository struct {

Issue struct {

ID githubv4.ID

} `graphql:"issue(number: $issueNumber)"`

DuplicateIssue struct {

ID githubv4.ID

} `graphql:"duplicateIssue: issue(number: $duplicateOf)"`

} `graphql:"repository(owner: $owner, name: $repo)"`

}

// Add duplicate issue number to variables

vars["duplicateOf"] = githubv4.Int(duplicateOf) // #nosec G115 - issue numbers are always small positive integers

if err := gqlClient.Query(ctx, &query, vars); err != nil {

return "", "", fmt.Errorf("failed to get issue ID: %w", err)

}

return query.Repository.Issue.ID, query.Repository.DuplicateIssue.ID, nil

}

// getCloseStateReason converts a string state reason to the appropriate enum value

func getCloseStateReason(stateReason string) IssueClosedStateReason {

switch stateReason {

case "not_planned":

return IssueClosedStateReasonNotPlanned

case "duplicate":

return IssueClosedStateReasonDuplicate

default: // Default to "completed" for empty or "completed" values

return IssueClosedStateReasonCompleted

}

}

// issueFieldWriteMetadataNode queries only the fields needed to resolve a write: the field's

// fullDatabaseId (BigInt scalar, returned as string) plus its name and data type for validation.

// shurcooL/githubv4 cannot use interface-level fragments at union top-level, so we repeat

// fullDatabaseId on each concrete type; all four implement IssueFieldCommon.

type issueFieldWriteMetadataNode struct {

TypeName githubv4.String `graphql:"__typename"`

IssueFieldText struct {

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

Name githubv4.String

DataType githubv4.String

} `graphql:"... on IssueFieldText"`

IssueFieldNumber struct {

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

Name githubv4.String

DataType githubv4.String

} `graphql:"... on IssueFieldNumber"`

IssueFieldDate struct {

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

Name githubv4.String

DataType githubv4.String

} `graphql:"... on IssueFieldDate"`

IssueFieldSingleSelect struct {

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

Name githubv4.String

DataType githubv4.String

Options []struct {

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

Name githubv4.String

}

} `graphql:"... on IssueFieldSingleSelect"`

}

type issueFieldWriteMetadataQuery struct {

Repository struct {

IssueFields struct {

Nodes []issueFieldWriteMetadataNode

} `graphql:"issueFields(first: 100)"`

} `graphql:"repository(owner: $owner, name: $repo)"`

}

// IssueFieldRef resolves the name of an issue field across its concrete types.

// IssueFields is a union of IssueFieldDate, IssueFieldNumber, IssueFieldSingleSelect, IssueFieldText,

// so we have to ask for `name` on each member.

type IssueFieldRef struct {

Date struct {

Name githubv4.String

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

} `graphql:"... on IssueFieldDate"`

Number struct {

Name githubv4.String

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

} `graphql:"... on IssueFieldNumber"`

SingleSelect struct {

Name githubv4.String

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

} `graphql:"... on IssueFieldSingleSelect"`

Text struct {

Name githubv4.String

FullDatabaseID githubv4.String `graphql:"fullDatabaseId"`

} `graphql:"... on IssueFieldText"`

}

// Name returns the populated name from whichever IssueFields union variant the field resolved to.

func (r IssueFieldRef) Name() string {

switch {

case r.Date.Name != "":

return string(r.Date.Name)

case r.Number.Name != "":

return string(r.Number.Name)

case r.SingleSelect.Name != "":

return string(r.SingleSelect.Name)

case r.Text.Name != "":

return string(r.Text.Name)

}

return ""

}

// FullDatabaseIDStr returns the fullDatabaseId string from whichever IssueFields union variant

// the field resolved to.

func (r IssueFieldRef) FullDatabaseIDStr() string {

switch {

case r.Date.FullDatabaseID != "":

return string(r.Date.FullDatabaseID)

case r.Number.FullDatabaseID != "":

return string(r.Number.FullDatabaseID)

case r.SingleSelect.FullDatabaseID != "":

return string(r.SingleSelect.FullDatabaseID)

case r.Text.FullDatabaseID != "":

return string(r.Text.FullDatabaseID)

}

return ""

}

// IssueFieldValueFragment captures the value of a custom issue field. IssueFieldValue is a union

// of 4 concrete value types; each carries its own value scalar and a reference to its parent field.

// The Number variant's `value` is aliased to `valueNumber` to avoid a Float vs String type clash on decode.

type IssueFieldValueFragment struct {

TypeName string `graphql:"__typename"`

DateValue struct {

Field IssueFieldRef

Value githubv4.String

} `graphql:"... on IssueFieldDateValue"`

NumberValue struct {

Field IssueFieldRef

Value githubv4.Float `graphql:"valueNumber: value"`

} `graphql:"... on IssueFieldNumberValue"`

SingleSelectValue struct {

Field IssueFieldRef

Value githubv4.String

} `graphql:"... on IssueFieldSingleSelectValue"`

TextValue struct {

Field IssueFieldRef

Value githubv4.String

} `graphql:"... on IssueFieldTextValue"`

}

func optionalIssueWriteFields(args map[string]any) ([]issueWriteFieldInput, error) {

issueFieldsRaw, exists := args["issue_fields"]

if !exists {

return nil, nil

}

var inputMaps []map[string]any

switch v := issueFieldsRaw.(type) {

case []any:

for _, item := range v {

itemMap, ok := item.(map[string]any)

if !ok {

return nil, fmt.Errorf("each issue_fields item must be an object")

}

inputMaps = append(inputMaps, itemMap)

}

case []map[string]any:

inputMaps = v

default:

return nil, fmt.Errorf("issue_fields must be an array")

}

issueFields := make([]issueWriteFieldInput, 0, len(inputMaps))

for _, itemMap := range inputMaps {

fieldName, err := RequiredParam[string](itemMap, "field_name")

if err != nil || strings.TrimSpace(fieldName) == "" {

return nil, fmt.Errorf("field_name is required for each issue_fields item")

}

fieldOptionName, err := OptionalParam[string](itemMap, "field_option_name")

if err != nil {

return nil, err

}

deleteField, err := OptionalParam[bool](itemMap, "delete")

if err != nil {

return nil, err

}

value, hasValue := itemMap["value"]

if hasValue && value == nil {

return nil, fmt.Errorf("value cannot be null for field %q", fieldName)

}

if deleteField {

if hasValue || fieldOptionName != "" {

return nil, fmt.Errorf("issue field %q cannot specify 'delete' together with 'value' or 'field_option_name'", fieldName)

}

issueFields = append(issueFields, issueWriteFieldInput{

FieldName: fieldName,

Delete: true,

})

continue

}

if hasValue && fieldOptionName != "" {

return nil, fmt.Errorf("issue field %q cannot specify both value and field_option_name", fieldName)

}

if !hasValue && fieldOptionName == "" {

return nil, fmt.Errorf("issue field %q must specify either value or field_option_name", fieldName)

}

issueFields = append(issueFields, issueWriteFieldInput{

FieldName: fieldName,

Value: value,

FieldOptionName: fieldOptionName,

})

}

return issueFields, nil

}

func resolveIssueRequestFieldValues(ctx context.Context, gqlClient *githubv4.Client, owner, repo string, issueFields []issueWriteFieldInput) ([]*github.IssueRequestFieldValue, []int64, error) {

if len(issueFields) == 0 {

return nil, nil, nil

}

ctxWithFeatures := ghcontext.WithGraphQLFeatures(ctx, "issue_fields", "repo_issue_fields")

var query issueFieldWriteMetadataQuery

vars := map[string]any{

"owner": githubv4.String(owner),

"repo": githubv4.String(repo),

}

if err := gqlClient.Query(ctxWithFeatures, &query, vars); err != nil {

return nil, nil, fmt.Errorf("failed to query issue fields metadata: %w", err)

}

// Build name → node map, dispatching on concrete type to extract name.

fieldByName := make(map[string]issueFieldWriteMetadataNode, len(query.Repository.IssueFields.Nodes))

for _, node := range query.Repository.IssueFields.Nodes {

var name string

switch string(node.TypeName) {

case "IssueFieldText":

name = string(node.IssueFieldText.Name)

case "IssueFieldNumber":

name = string(node.IssueFieldNumber.Name)

case "IssueFieldDate":

name = string(node.IssueFieldDate.Name)

case "IssueFieldSingleSelect":

name = string(node.IssueFieldSingleSelect.Name)

default:

continue

}

fieldByName[strings.ToLower(strings.TrimSpace(name))] = node

}

resolved := make([]*github.IssueRequestFieldValue, 0, len(issueFields))

var fieldIDsToDelete []int64

for _, fieldInput := range issueFields {

node, ok := fieldByName[strings.ToLower(strings.TrimSpace(fieldInput.FieldName))]

if !ok {

return nil, nil, fmt.Errorf("issue field %q was not found in %s/%s", fieldInput.FieldName, owner, repo)

}

var fullDatabaseIDStr, dataType string

switch string(node.TypeName) {

case "IssueFieldText":

fullDatabaseIDStr = string(node.IssueFieldText.FullDatabaseID)

dataType = string(node.IssueFieldText.DataType)

case "IssueFieldNumber":

fullDatabaseIDStr = string(node.IssueFieldNumber.FullDatabaseID)

dataType = string(node.IssueFieldNumber.DataType)

case "IssueFieldDate":

fullDatabaseIDStr = string(node.IssueFieldDate.FullDatabaseID)

dataType = string(node.IssueFieldDate.DataType)

case "IssueFieldSingleSelect":

fullDatabaseIDStr = string(node.IssueFieldSingleSelect.FullDatabaseID)

dataType = string(node.IssueFieldSingleSelect.DataType)

}

fieldID := parseFullDatabaseID(fullDatabaseIDStr)

if fieldID == 0 {

return nil, nil, fmt.Errorf("issue field %q is missing fullDatabaseId", fieldInput.FieldName)

}

if fieldInput.Delete {

fieldIDsToDelete = append(fieldIDsToDelete, fieldID)

continue

}

resolvedValue := fieldInput.Value

if fieldInput.FieldOptionName != "" {

if !strings.EqualFold(dataType, "single_select") {

return nil, nil, fmt.Errorf("issue field %q is %q, so field_option_name cannot be used", fieldInput.FieldName, dataType)

}

optionFound := false

for _, option := range node.IssueFieldSingleSelect.Options {

if strings.EqualFold(strings.TrimSpace(string(option.Name)), strings.TrimSpace(fieldInput.FieldOptionName)) {

// REST API expects the option name, not the ID

resolvedValue = string(option.Name)

optionFound = true

break

}

}

if !optionFound {

return nil, nil, fmt.Errorf("issue field option %q was not found for field %q", fieldInput.FieldOptionName, fieldInput.FieldName)

}

}

resolved = append(resolved, &github.IssueRequestFieldValue{

FieldID: fieldID,

Value: resolvedValue,

})

}

return resolved, fieldIDsToDelete, nil

}

// fetchExistingIssueFieldValues retrieves the current field values for an issue

// as IssueRequestFieldValue entries, ready to be merged before an update.

func fetchExistingIssueFieldValues(ctx context.Context, gqlClient *githubv4.Client, owner, repo string, issueNumber int) ([]*github.IssueRequestFieldValue, error) {

ctxWithFeatures := ghcontext.WithGraphQLFeatures(ctx, "issue_fields", "repo_issue_fields")

var query struct {

Repository struct {

Issue struct {

IssueFieldValues struct {

Nodes []IssueFieldValueFragment

} `graphql:"issueFieldValues(first: 25)"`

} `graphql:"issue(number: $number)"`

} `graphql:"repository(owner: $owner, name: $repo)"`

}

vars := map[string]any{

"owner": githubv4.String(owner),

"repo": githubv4.String(repo),

"number": githubv4.Int(issueNumber), // #nosec G115 - issue numbers are always small positive integers

}

if err := gqlClient.Query(ctxWithFeatures, &query, vars); err != nil {

return nil, fmt.Errorf("failed to fetch existing issue field values: %w", err)

}

var result []*github.IssueRequestFieldValue

for _, node := range query.Repository.Issue.IssueFieldValues.Nodes {

var fieldIDStr string

var value any

switch node.TypeName {

case "IssueFieldDateValue":

fieldIDStr = node.DateValue.Field.FullDatabaseIDStr()

value = string(node.DateValue.Value)

case "IssueFieldNumberValue":

fieldIDStr = node.NumberValue.Field.FullDatabaseIDStr()

value = float64(node.NumberValue.Value)

case "IssueFieldSingleSelectValue":

fieldIDStr = node.SingleSelectValue.Field.FullDatabaseIDStr()

value = string(node.SingleSelectValue.Value)

case "IssueFieldTextValue":

fieldIDStr = node.TextValue.Field.FullDatabaseIDStr()

value = string(node.TextValue.Value)

default:

continue

}

fieldID := parseFullDatabaseID(fieldIDStr)

if fieldID == 0 {

continue

}

result = append(result, &github.IssueRequestFieldValue{

FieldID: fieldID,

Value: value,

})

}

return result, nil

}

// mergeIssueFieldValues returns a merged slice where incoming values override existing ones

// for the same field ID, and existing fields not present in incoming are preserved.

// Ordering is deterministic: incoming entries first in their original order, followed by any

// existing entries (in their original order) whose field IDs weren't seen in incoming.

func mergeIssueFieldValues(existing, incoming []*github.IssueRequestFieldValue) []*github.IssueRequestFieldValue {

seen := make(map[int64]struct{}, len(incoming))

result := make([]*github.IssueRequestFieldValue, 0, len(existing)+len(incoming))

for _, v := range incoming {

seen[v.FieldID] = struct{}{}

result = append(result, v)

}

for _, v := range existing {

if _, ok := seen[v.FieldID]; ok {

continue

}

result = append(result, v)

}

return result

}

// IssueFragment represents a fragment of an issue node in the GraphQL API.

type IssueFragment struct {

Number githubv4.Int

Title githubv4.String

Body githubv4.String

State githubv4.String

DatabaseID int64

Author struct {

Login githubv4.String

}

CreatedAt githubv4.DateTime

UpdatedAt githubv4.DateTime

Labels struct {

Nodes []struct {

Name githubv4.String

ID githubv4.String

Description githubv4.String

}

} `graphql:"labels(first: 100)"`

// GitHub caps issue assignees at 10, so first: 100 cannot truncate.

Assignees struct {

Nodes []struct {

Login githubv4.String

}

} `graphql:"assignees(first: 100)"`

Comments struct {

TotalCount githubv4.Int

} `graphql:"comments"`

IssueFieldValues struct {

Nodes []IssueFieldValueFragment

} `graphql:"issueFieldValues(first: 25)"`

}

type issueFragmentWithoutFieldValues struct {

Number githubv4.Int

Title githubv4.String

Body githubv4.String

State githubv4.String

DatabaseID int64

Author struct {

Login githubv4.String

}

CreatedAt githubv4.DateTime

UpdatedAt githubv4.DateTime

Labels struct {

Nodes []struct {

Name githubv4.String

ID githubv4.String

Description githubv4.String

}

} `graphql:"labels(first: 100)"`

Assignees struct {

Nodes []struct {

Login githubv4.String

}

} `graphql:"assignees(first: 100)"`

Comments struct {

TotalCount githubv4.Int

} `graphql:"comments"`

}

// Common interface for all issue query types

type IssueQueryResult interface {

GetIssueFragment() IssueQueryFragment

GetIsPrivate() bool

}

type issueQueryResultWithoutFieldValues interface {

getIssueFragmentWithoutFieldValues() issueQueryFragmentWithoutFieldValues

GetIsPrivate() bool

}

type IssueQueryFragment struct {

Nodes []IssueFragment `graphql:"nodes"`

PageInfo struct {

HasNextPage githubv4.Boolean

HasPreviousPage githubv4.Boolean

StartCursor githubv4.String

EndCursor githubv4.String

}

TotalCount int

}

type issueQueryFragmentWithoutFieldValues struct {

Nodes []issueFragmentWithoutFieldValues `graphql:"nodes"`

PageInfo struct {

HasNextPage githubv4.Boolean

HasPreviousPage githubv4.Boolean

StartCursor githubv4.String

EndCursor githubv4.String

}

TotalCount int

}

// ListIssuesQuery is the root query structure for fetching issues with optional label filtering.

type ListIssuesQuery struct {

Repository struct {

Issues IssueQueryFragment `graphql:"issues(first: $first, after: $after, states: $states, orderBy: {field: $orderBy, direction: $direction}, filterBy: {issueFieldValues: $issueFieldValues})"`

IsPrivate githubv4.Boolean

} `graphql:"repository(owner: $owner, name: $repo)"`

}

// ListIssuesQueryTypeWithLabels is the query structure for fetching issues with optional label filtering.

type ListIssuesQueryTypeWithLabels struct {

Repository struct {

Issues IssueQueryFragment `graphql:"issues(first: $first, after: $after, labels: $labels, states: $states, orderBy: {field: $orderBy, direction: $direction}, filterBy: {issueFieldValues: $issueFieldValues})"`

IsPrivate githubv4.Boolean

} `graphql:"repository(owner: $owner, name: $repo)"`

}

// ListIssuesQueryWithSince is the query structure for fetching issues without label filtering but with since filtering.

type ListIssuesQueryWithSince struct {

Repository struct {

Issues IssueQueryFragment `graphql:"issues(first: $first, after: $after, states: $states, orderBy: {field: $orderBy, direction: $direction}, filterBy: {since: $since, issueFieldValues: $issueFieldValues})"`

IsPrivate githubv4.Boolean

} `graphql:"repository(owner: $owner, name: $repo)"`

}

// ListIssuesQueryTypeWithLabelsWithSince is the query structure for fetching issues with both label and since filtering.

type ListIssuesQueryTypeWithLabelsWithSince struct {

Repository struct {

Issues IssueQueryFragment `graphql:"issues(first: $first, after: $after, labels: $labels, states: $states, orderBy: {field: $orderBy, direction: $direction}, filterBy: {since: $since, issueFieldValues: $issueFieldValues})"`

IsPrivate githubv4.Boolean

} `graphql:"repository(owner: $owner, name: $repo)"`

}

type listIssuesQueryWithoutFieldValues struct {

Repository struct {

Issues issueQueryFragmentWithoutFieldValues `graphql:"issues(first: $first, after: $after, states: $states, orderBy: {field: $orderBy, direction: $direction})"`

IsPrivate githubv4.Boolean

} `graphql:"repository(owner: $owner, name: $repo)"`

}

type listIssuesQueryWithLabelsWithoutFieldValues struct {

Repository struct {

Issues issueQueryFragmentWithoutFieldValues `graphql:"issues(first: $first, after: $after, labels: $labels, states: $states, orderBy: {field: $orderBy, direction: $direction})"`

IsPrivate githubv4.Boolean

} `graphql:"repository(owner: $owner, name: $repo)"`

}

type listIssuesQueryWithSinceWithoutFieldValues struct {

Repository struct {

Issues issueQueryFragmentWithoutFieldValues `graphql:"issues(first: $first, after: $after, states: $states, orderBy: {field: $orderBy, direction: $direction}, filterBy: {since: $since})"`

IsPrivate githubv4.Boolean

} `graphql:"repository(owner: $owner, name: $repo)"`

}

type listIssuesQueryWithLabelsAndSinceWithoutFieldValues struct {

Repository struct {

Issues issueQueryFragmentWithoutFieldValues `graphql:"issues(first: $first, after: $after, labels: $labels, states: $states, orderBy: {field: $orderBy, direction: $direction}, filterBy: {since: $since})"`

IsPrivate githubv4.Boolean

} `graphql:"repository(owner: $owner, name: $repo)"`

}

// IssueFieldValueFilter mirrors the GraphQL IssueFieldValueFilter input. Exactly one typed value

// field should be set per filter (the monolith resolver rejects multiple).

type IssueFieldValueFilter struct {

FieldName githubv4.String `json:"fieldName"`

TextValue *githubv4.String `json:"textValue,omitempty"`

DateValue *githubv4.String `json:"dateValue,omitempty"`

NumberValue *githubv4.Float `json:"numberValue,omitempty"`

SingleSelectOptionValue *githubv4.String `json:"singleSelectOptionValue,omitempty"`

}

// Implement the interface for all query types

func (q *ListIssuesQueryTypeWithLabels) GetIssueFragment() IssueQueryFragment {

return q.Repository.Issues

}

func (q *ListIssuesQueryTypeWithLabels) GetIsPrivate() bool { return bool(q.Repository.IsPrivate) }

func (q *ListIssuesQuery) GetIssueFragment() IssueQueryFragment {

return q.Repository.Issues

}

func (q *ListIssuesQuery) GetIsPrivate() bool { return bool(q.Repository.IsPrivate) }

func (q *ListIssuesQueryWithSince) GetIssueFragment() IssueQueryFragment {

return q.Repository.Issues

}

func (q *ListIssuesQueryWithSince) GetIsPrivate() bool { return bool(q.Repository.IsPrivate) }

func (q *ListIssuesQueryTypeWithLabelsWithSince) GetIssueFragment() IssueQueryFragment {

return q.Repository.Issues

}

func (q *ListIssuesQueryTypeWithLabelsWithSince) GetIsPrivate() bool {

return bool(q.Repository.IsPrivate)

}

func (q *listIssuesQueryWithoutFieldValues) getIssueFragmentWithoutFieldValues() issueQueryFragmentWithoutFieldValues {

return q.Repository.Issues

}

func (q *listIssuesQueryWithoutFieldValues) GetIsPrivate() bool {

return bool(q.Repository.IsPrivate)

}

func (q *listIssuesQueryWithLabelsWithoutFieldValues) getIssueFragmentWithoutFieldValues() issueQueryFragmentWithoutFieldValues {

return q.Repository.Issues

}

func (q *listIssuesQueryWithLabelsWithoutFieldValues) GetIsPrivate() bool {

return bool(q.Repository.IsPrivate)

}

func (q *listIssuesQueryWithSinceWithoutFieldValues) getIssueFragmentWithoutFieldValues() issueQueryFragmentWithoutFieldValues {

return q.Repository.Issues

}

func (q *listIssuesQueryWithSinceWithoutFieldValues) GetIsPrivate() bool {

return bool(q.Repository.IsPrivate)

}

func (q *listIssuesQueryWithLabelsAndSinceWithoutFieldValues) getIssueFragmentWithoutFieldValues() issueQueryFragmentWithoutFieldValues {

return q.Repository.Issues

}

func (q *listIssuesQueryWithLabelsAndSinceWithoutFieldValues) GetIsPrivate() bool {

return bool(q.Repository.IsPrivate)

}

func getIssueQueryType(hasLabels bool, hasSince bool) IssueQueryResult {

switch {

case hasLabels && hasSince:

return &ListIssuesQueryTypeWithLabelsWithSince{}

case hasLabels:

return &ListIssuesQueryTypeWithLabels{}

case hasSince:

return &ListIssuesQueryWithSince{}

default:

return &ListIssuesQuery{}

}

}

func getIssueQueryTypeWithoutFieldValues(hasLabels bool, hasSince bool) issueQueryResultWithoutFieldValues {

switch {

case hasLabels && hasSince:

return &listIssuesQueryWithLabelsAndSinceWithoutFieldValues{}

case hasLabels:

return &listIssuesQueryWithLabelsWithoutFieldValues{}

case hasSince:

return &listIssuesQueryWithSinceWithoutFieldValues{}

default:

return &listIssuesQueryWithoutFieldValues{}

}

}

func isUnsupportedIssueFieldValuesSchemaError(err error) bool {

if err == nil {

return false

}

message := strings.ToLower(err.Error())

mentionsIssueType := strings.Contains(message, "on type 'issue'") ||

strings.Contains(message, `on type "issue"`) ||

strings.Contains(message, "on type issue")

if strings.Contains(message, "issuefieldvalues") &&

mentionsIssueType &&

(strings.Contains(message, "doesn't exist on type") ||

strings.Contains(message, "does not exist on type") ||

strings.Contains(message, "cannot query field") ||

strings.Contains(message, "is not defined on type")) {

return true

}

issueFieldTypes := [...]string{

"issuefielddate",

"issuefieldnumber",

"issuefieldsingleselect",

"issuefieldtext",

}

for _, issueFieldType := range issueFieldTypes {

if !strings.Contains(message, issueFieldType) {

continue

}

return strings.Contains(message, "unknown type") ||

strings.Contains(message, "isn't a defined type") ||

strings.Contains(message, "is not a defined type") ||

strings.Contains(message, "fragment cannot be spread") ||

strings.Contains(message, "can never be of type")

}

return false

}

func isUnsupportedListIssuesIssueFieldsError(err error) bool {

if isUnsupportedIssueFieldValuesSchemaError(err) {

return true

}

message := err.Error()

if strings.Contains(message, "IssueFieldValueFilter") {

return true

}

if !strings.Contains(message, "issueFieldValues") {

return false

}

return strings.Contains(message, "doesn't exist on type") ||

strings.Contains(message, "doesn't accept argument") ||

(strings.Contains(message, "Argument 'filterBy'") && strings.Contains(message, "invalid value"))

}

// IssueRead creates a tool to get details of a specific issue in a GitHub repository.

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

schema := &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"method": {

Type: "string",

Description: "The read operation to perform on a single issue.\n" +

"Options are:\n" +

"1. get - Get issue details. Also returns best-effort hierarchy flags (`has_parent`, `has_children`); `parent` and `sub_issues_summary` are optional relationship summaries, and `closed_by_pull_requests` summarizes the pull requests configured to close the issue as `total_count` plus up to 5 `references`.\n" +

"2. get_comments - Get issue comments.\n" +

"3. get_sub_issues - Get sub-issues (children) of the issue.\n" +

"4. get_parent - Get the parent issue, if this issue is a sub-issue of another.\n" +

"5. get_labels - Get labels assigned to the issue.\n",

Enum: []any{"get", "get_comments", "get_sub_issues", "get_parent", "get_labels"},

},

"owner": {

Type: "string",

Description: "The owner of the repository",

},

"repo": {

Type: "string",

Description: "The name of the repository",

},

"issue_number": {

Type: "number",

Description: "The number of the issue",

},

},

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

}

WithPagination(schema)

return NewTool[IssueReadInput, *IssueReadOutput](

ToolsetMetadataIssues,

mcp.Tool{

Name: "issue_read",

OutputSchema: issueReadOutputSchema(),

Description: t("TOOL_ISSUE_READ_DESCRIPTION", "Get information about a specific issue in a GitHub repository."),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_ISSUE_READ_USER_TITLE", "Get issue details"),

ReadOnlyHint: true,

},

InputSchema: schema,

},

scopes.PublicRead(scopes.Repo),

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, input IssueReadInput) (*mcp.CallToolResult, *IssueReadOutput, error) {

args, err := discussionNotificationArguments(input)

if err != nil {

return nil, nil, err

}

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

if err != nil {

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

}

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

}

issueNumber, err := RequiredInt(args, "issue_number")

if err != nil {

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

}

pagination, err := OptionalPaginationParams(args)

if err != nil {

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

}

client, err := deps.GetClient(ctx)

if err != nil {

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

}

gqlClient, err := deps.GetGQLClient(ctx)

if err != nil {

return utils.NewToolResultErrorFromErr("failed to get GitHub graphql client", err), nil, nil

}

// attachIFC adds the IFC label to a successful tool result when

// IFC labels are enabled. If the visibility lookup fails the

// label is omitted rather than misclassifying the result.

attachIFC := newRepoVisibilityIFCLabeler(ctx, deps, client, owner, repo, ifc.LabelRepoUserContent)

switch method {

case "get":

result, output, err := getIssue(ctx, client, deps, owner, repo, issueNumber)

return attachIFC(result), output, err

case "get_comments":

result, output, err := getIssueComments(ctx, client, deps, owner, repo, issueNumber, pagination)

return attachIFC(result), output, err

case "get_sub_issues":

result, output, err := getSubIssues(ctx, client, deps, owner, repo, issueNumber, pagination)

return attachIFC(result), output, err

case "get_parent":

result, output, err := getIssueParent(ctx, gqlClient, deps, owner, repo, issueNumber)

return attachIFC(result), output, err

case "get_labels":

result, output, err := getIssueLabels(ctx, gqlClient, owner, repo, issueNumber)

return attachIFC(result), output, err

default:

return utils.NewToolResultError(fmt.Sprintf("unknown method: %s", method)), nil, nil

}

}, normalizeConsolidatedIssueArguments("read"))

}

func GetIssue(ctx context.Context, client *github.Client, deps ToolDependencies, owner string, repo string, issueNumber int) (*mcp.CallToolResult, error) {

result, _, err := getIssue(ctx, client, deps, owner, repo, issueNumber)

return result, err

}

func getIssue(ctx context.Context, client *github.Client, deps ToolDependencies, owner string, repo string, issueNumber int) (*mcp.CallToolResult, *IssueReadOutput, error) {

cache, err := deps.GetRepoAccessCache(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get repo access cache: %w", err)

}

flags := deps.GetFlags(ctx)

issue, resp, err := client.Issues.Get(ctx, owner, repo, issueNumber)

if err != nil {

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

}

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 get issue", resp, body), nil, nil

}

if flags.LockdownMode {

if restricted, err := authorLockdownResult(ctx, cache, owner, repo, issue.GetUser().GetLogin(), lockdownIssueRestrictedMessage); restricted != nil || err != nil {

return restricted, nil, err

}

}

minimalIssue := convertToMinimalIssue(issue)

// Always drop the verbose REST IssueFieldValues; enrich with the GraphQL

// field_values view and the hierarchy relationship signals instead. The

// enrichment is best-effort: a failure here must never fail `get`.

minimalIssue.IssueFieldValues = nil

if issue != nil && issue.NodeID != nil && *issue.NodeID != "" {

gqlClient, err := deps.GetGQLClient(ctx)

if err == nil {

if enrichment, err := fetchIssueReadEnrichment(ctx, gqlClient, *issue.NodeID); err == nil {

applyIssueReadEnrichment(ctx, &minimalIssue, enrichment, cache, flags.LockdownMode)

}

}

}

return MarshalledTextResult(minimalIssue), &IssueReadOutput{Method: "get", Issue: issueDetailsOutput(minimalIssue)}, nil

}

// applyIssueReadEnrichment populates the hierarchy relationship signals (has_parent/has_children,

// parent, sub_issues_summary), the closing pull request references, and field_values onto the

// minimal issue. In lockdown mode references whose content cannot be verified as safe are omitted;

// has_parent and the numeric counts are structural routing signals and are always safe to surface.

func applyIssueReadEnrichment(ctx context.Context, minimalIssue *MinimalIssue, enrichment *issueReadEnrichment, cache *lockdown.RepoAccessCache, lockdownMode bool) {

if enrichment == nil {

return

}

minimalIssue.FieldValues = enrichment.FieldValues

minimalIssue.HasParent = ToBoolPtr(enrichment.Parent != nil)

minimalIssue.HasChildren = ToBoolPtr(enrichment.SubIssuesSummary.Total > 0)

if parent := enrichment.Parent; parent != nil {

// Surface the parent reference only when it is safe to expose. Under lockdown an

// unverified (possibly cross-repo) parent is omitted entirely, mirroring how unsafe

// comments and sub-issues are filtered out. has_parent still routes an agent to

// get_parent if it needs to follow up.

if !lockdownMode || isSafeRefContent(ctx, cache, parent.Ref.Repository, parent.AuthorLogin) {

ref := parent.Ref

minimalIssue.Parent = &ref

}

}

// A zero total is meaningful here: it tells an agent that nothing is currently set up to close

// the issue, so it does not need to fall back to scanning pull requests. Only a few references

// are embedded, so total_count is what distinguishes a complete list from a truncated one.

closing := MinimalClosingPullRequests{

TotalCount: enrichment.ClosedByPullRequestsTotal,

References: make([]MinimalPullRequestRef, 0, len(enrichment.ClosedByPullRequests)),

}

for _, pr := range enrichment.ClosedByPullRequests {

if lockdownMode && !isSafeRefContent(ctx, cache, pr.Ref.Repository, pr.AuthorLogin) {

continue

}

closing.References = append(closing.References, pr.Ref)

}

minimalIssue.ClosedByPullRequests = &closing

if enrichment.SubIssuesSummary.Total > 0 {

summary := enrichment.SubIssuesSummary

minimalIssue.SubIssuesSummary = &summary

}

}

// isSafeRefContent reports whether a related issue or pull request reference can be exposed under

// lockdown mode. It fails closed: any inability to positively verify safe content (missing cache,

// missing author, unparseable repository, or a lookup error) results in the reference being omitted.