Skip to content

validate tools params #35

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Mar 24, 2025
Merged

validate tools params #35

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4d7388a
validate tools params
juruen Mar 24, 2025
3c6467f
use generic for helper functions
juruen Mar 24, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 32 additions & 8 deletions pkg/github/code_scanning.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,9 +30,18 @@ func getCodeScanningAlert(client *github.Client, t translations.TranslationHelpe
),
),
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
owner, _ := request.Params.Arguments["owner"].(string)
repo, _ := request.Params.Arguments["repo"].(string)
alertNumber, _ := request.Params.Arguments["alert_number"].(float64)
owner, err := requiredParam[string](request, "owner")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
repo, err := requiredParam[string](request, "repo")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
alertNumber, err := requiredInt(request, "alert_number")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

alert, resp, err := client.CodeScanning.GetAlert(ctx, owner, repo, int64(alertNumber))
if err != nil {
Expand Down Expand Up @@ -80,11 +89,26 @@ func listCodeScanningAlerts(client *github.Client, t translations.TranslationHel
),
),
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
owner, _ := request.Params.Arguments["owner"].(string)
repo, _ := request.Params.Arguments["repo"].(string)
ref, _ := request.Params.Arguments["ref"].(string)
state, _ := request.Params.Arguments["state"].(string)
severity, _ := request.Params.Arguments["severity"].(string)
owner, err := requiredParam[string](request, "owner")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
repo, err := requiredParam[string](request, "repo")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
ref, err := optionalParam[string](request, "ref")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
state, err := optionalParam[string](request, "state")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
severity, err := optionalParam[string](request, "severity")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

alerts, resp, err := client.CodeScanning.ListAlertsForRepo(ctx, owner, repo, &github.AlertListOptions{Ref: ref, State: state, Severity: severity})
if err != nil {
Expand Down
197 changes: 137 additions & 60 deletions pkg/github/issues.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -32,9 +32,18 @@ func getIssue(client *github.Client, t translations.TranslationHelperFunc) (tool
),
),
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
owner := request.Params.Arguments["owner"].(string)
repo := request.Params.Arguments["repo"].(string)
issueNumber := int(request.Params.Arguments["issue_number"].(float64))
owner, err := requiredParam[string](request, "owner")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
repo, err := requiredParam[string](request, "repo")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
issueNumber, err := requiredInt(request, "issue_number")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

issue, resp, err := client.Issues.Get(ctx, owner, repo, issueNumber)
if err != nil {
Expand Down Expand Up @@ -81,10 +90,22 @@ func addIssueComment(client *github.Client, t translations.TranslationHelperFunc
),
),
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
owner := request.Params.Arguments["owner"].(string)
repo := request.Params.Arguments["repo"].(string)
issueNumber := int(request.Params.Arguments["issue_number"].(float64))
body := request.Params.Arguments["body"].(string)
owner, err := requiredParam[string](request, "owner")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
repo, err := requiredParam[string](request, "repo")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
issueNumber, err := requiredInt(request, "issue_number")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
body, err := requiredParam[string](request, "body")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

comment := &github.IssueComment{
Body: github.Ptr(body),
Expand Down Expand Up @@ -135,22 +156,25 @@ func searchIssues(client *github.Client, t translations.TranslationHelperFunc) (
),
),
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
query := request.Params.Arguments["q"].(string)
sort := ""
if s, ok := request.Params.Arguments["sort"].(string); ok {
sort = s
query, err := requiredParam[string](request, "q")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
order := ""
if o, ok := request.Params.Arguments["order"].(string); ok {
order = o
sort, err := optionalParam[string](request, "sort")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
perPage := 30
if pp, ok := request.Params.Arguments["per_page"].(float64); ok {
perPage = int(pp)
order, err := optionalParam[string](request, "order")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
page := 1
if p, ok := request.Params.Arguments["page"].(float64); ok {
page = int(p)
perPage, err := optionalIntParamWithDefault(request, "per_page", 30)
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
page, err := optionalIntParamWithDefault(request, "page", 1)
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

opts := &github.SearchOptions{
Expand Down Expand Up @@ -212,26 +236,34 @@ func createIssue(client *github.Client, t translations.TranslationHelperFunc) (t
),
),
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
owner := request.Params.Arguments["owner"].(string)
repo := request.Params.Arguments["repo"].(string)
title := request.Params.Arguments["title"].(string)
owner, err := requiredParam[string](request, "owner")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
repo, err := requiredParam[string](request, "repo")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
title, err := requiredParam[string](request, "title")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

// Optional parameters
var body string
if b, ok := request.Params.Arguments["body"].(string); ok {
body = b
body, err := optionalParam[string](request, "body")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

// Parse assignees if present
assignees := []string{} // default to empty slice, can't be nil
if a, ok := request.Params.Arguments["assignees"].(string); ok && a != "" {
assignees = parseCommaSeparatedList(a)
// Get assignees
assignees, err := optionalCommaSeparatedListParam(request, "assignees")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

// Parse labels if present
labels := []string{} // default to empty slice, can't be nil
if l, ok := request.Params.Arguments["labels"].(string); ok && l != "" {
labels = parseCommaSeparatedList(l)
// Get labels
labels, err := optionalCommaSeparatedListParam(request, "labels")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

// Create the issue request
Expand Down Expand Up @@ -300,29 +332,43 @@ func listIssues(client *github.Client, t translations.TranslationHelperFunc) (to
),
),
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
owner := request.Params.Arguments["owner"].(string)
repo := request.Params.Arguments["repo"].(string)
owner, err := requiredParam[string](request, "owner")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
repo, err := requiredParam[string](request, "repo")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

opts := &github.IssueListByRepoOptions{}

// Set optional parameters if provided
if state, ok := request.Params.Arguments["state"].(string); ok && state != "" {
opts.State = state
opts.State, err = optionalParam[string](request, "state")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

if labels, ok := request.Params.Arguments["labels"].(string); ok && labels != "" {
opts.Labels = parseCommaSeparatedList(labels)
opts.Labels, err = optionalCommaSeparatedListParam(request, "labels")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

if sort, ok := request.Params.Arguments["sort"].(string); ok && sort != "" {
opts.Sort = sort
opts.Sort, err = optionalParam[string](request, "sort")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

if direction, ok := request.Params.Arguments["direction"].(string); ok && direction != "" {
opts.Direction = direction
opts.Direction, err = optionalParam[string](request, "direction")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

if since, ok := request.Params.Arguments["since"].(string); ok && since != "" {
since, err := optionalParam[string](request, "since")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
if since != "" {
timestamp, err := parseISOTimestamp(since)
if err != nil {
return mcp.NewToolResultError(fmt.Sprintf("failed to list issues: %s", err.Error())), nil
Expand Down Expand Up @@ -397,38 +443,69 @@ func updateIssue(client *github.Client, t translations.TranslationHelperFunc) (t
),
),
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
owner := request.Params.Arguments["owner"].(string)
repo := request.Params.Arguments["repo"].(string)
issueNumber := int(request.Params.Arguments["issue_number"].(float64))
owner, err := requiredParam[string](request, "owner")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
repo, err := requiredParam[string](request, "repo")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
issueNumber, err := requiredInt(request, "issue_number")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}

// Create the issue request with only provided fields
issueRequest := &github.IssueRequest{}

// Set optional parameters if provided
if title, ok := request.Params.Arguments["title"].(string); ok && title != "" {
title, err := optionalParam[string](request, "title")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
if title != "" {
issueRequest.Title = github.Ptr(title)
}

if body, ok := request.Params.Arguments["body"].(string); ok && body != "" {
body, err := optionalParam[string](request, "body")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
if body != "" {
issueRequest.Body = github.Ptr(body)
}

if state, ok := request.Params.Arguments["state"].(string); ok && state != "" {
state, err := optionalParam[string](request, "state")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
if state != "" {
issueRequest.State = github.Ptr(state)
}

if labels, ok := request.Params.Arguments["labels"].(string); ok && labels != "" {
labelsList := parseCommaSeparatedList(labels)
issueRequest.Labels = &labelsList
labels, err := optionalCommaSeparatedListParam(request, "labels")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
if len(labels) > 0 {
issueRequest.Labels = &labels
}

if assignees, ok := request.Params.Arguments["assignees"].(string); ok && assignees != "" {
assigneesList := parseCommaSeparatedList(assignees)
issueRequest.Assignees = &assigneesList
assignees, err := optionalCommaSeparatedListParam(request, "assignees")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
if len(assignees) > 0 {
issueRequest.Assignees = &assignees
}

if milestone, ok := request.Params.Arguments["milestone"].(float64); ok {
milestoneNum := int(milestone)
milestone, err := optionalIntParam(request, "milestone")
if err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
if milestone != 0 {
milestoneNum := milestone
issueRequest.Milestone = &milestoneNum
}

Expand Down
26 changes: 20 additions & 6 deletions pkg/github/issues_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -176,8 +176,8 @@ func Test_AddIssueComment(t *testing.T) {
"issue_number": float64(42),
"body": "",
},
expectError: true,
expectedErrMsg: "failed to create comment",
expectError: false,
expectedErrMsg: "missing required parameter: body",
},
}

Expand Down Expand Up @@ -210,6 +210,13 @@ func Test_AddIssueComment(t *testing.T) {
return
}

if tc.expectedErrMsg != "" {
require.NotNil(t, result)
textContent := getTextResult(t, result)
assert.Contains(t, textContent.Text, tc.expectedErrMsg)
return
}

require.NoError(t, err)

// Parse the result and get the text content if no error
Expand Down Expand Up @@ -419,8 +426,8 @@ func Test_CreateIssue(t *testing.T) {
"repo": "repo",
"title": "Test Issue",
"body": "This is a test issue",
"assignees": []interface{}{"user1", "user2"},
"labels": []interface{}{"bug", "help wanted"},
"assignees": "user1, user2",
"labels": "bug, help wanted",
},
expectError: false,
expectedIssue: mockIssue,
Expand Down Expand Up @@ -467,8 +474,8 @@ func Test_CreateIssue(t *testing.T) {
"repo": "repo",
"title": "",
},
expectError: true,
expectedErrMsg: "failed to create issue",
expectError: false,
expectedErrMsg: "missing required parameter: title",
},
}

Expand All @@ -491,6 +498,13 @@ func Test_CreateIssue(t *testing.T) {
return
}

if tc.expectedErrMsg != "" {
require.NotNil(t, result)
textContent := getTextResult(t, result)
assert.Contains(t, textContent.Text, tc.expectedErrMsg)
return
}

require.NoError(t, err)
textContent := getTextResult(t, result)

Expand Down
Loading