Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

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.

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

Already on GitHub?Sign in to your account

Merged
juruen merged 2 commits intomainfromjuruen/validate-params
Mar 24, 2025
Merged
Show file tree
Hide file tree
Changes fromall commits
Commits
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 deletionspkg/github/code_scanning.go
View file
Open in desktop
Original file line numberDiff line numberDiff 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 DownExpand 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 deletionspkg/github/issues.go
View file
Open in desktop
Original file line numberDiff line numberDiff 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 DownExpand 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 DownExpand 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:=""
ifo, ok := request.Params.Arguments["order"].(string); ok {
order = o
sort, err:=optionalParam[string](request, "sort")
iferr != nil {
return mcp.NewToolResultError(err.Error()), nil
}
perPage:=30
ifpp, ok := request.Params.Arguments["per_page"].(float64); ok {
perPage = int(pp)
order, err:=optionalParam[string](request, "order")
iferr != 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 DownExpand 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
varbodystring
ifb, ok := request.Params.Arguments["body"].(string); ok {
body = b
body, err := optionalParam[string](request, "body")
iferr != nil {
return mcp.NewToolResultError(err.Error()), nil
}

//Parse assignees if present
assignees:=[]string{} // default to empty slice, can't be nil
ifa, ok := request.Params.Arguments["assignees"].(string); ok && a!="" {
assignees = parseCommaSeparatedList(a)
//Get assignees
assignees, err:=optionalCommaSeparatedListParam(request, "assignees")
iferr!=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 DownExpand 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 DownExpand 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 deletionspkg/github/issues_test.go
View file
Open in desktop
Original file line numberDiff line numberDiff 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 DownExpand 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 DownExpand 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 DownExpand 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
[8]ページ先頭
©2009-2025 Movatter.jp