Add new RequiredIntArrayParam helper

Author: lumaxis

pkg/github/issues.go

@@ -1480,16 +1480,11 @@ func FindClosingPullRequests(getGQLClient GetGQLClientFn, t translations.Transla
 			if err != nil {
 				return mcp.NewToolResultError(fmt.Sprintf("repo parameter error: %s", err.Error())), nil
 			}
-			issueNumbers, err := OptionalIntArrayParam(request, "issue_numbers")
+			issueNumbers, err := RequiredIntArrayParam(request, "issue_numbers")
 			if err != nil {
 				return mcp.NewToolResultError(fmt.Sprintf("issue_numbers parameter error: %s", err.Error())), nil
 			}
 
-			// Validate that issue_numbers is not empty
-			if len(issueNumbers) == 0 {
-				return mcp.NewToolResultError("issue_numbers parameter is required and cannot be empty - provide at least one issue number"), nil
-			}
-
 			// Get GraphQL client
 			client, err := getGQLClient(ctx)
 			if err != nil {

pkg/github/server.go

@@ -99,6 +99,50 @@ func RequiredInt(r mcp.CallToolRequest, p string) (int, error) {
 	return int(v), nil
 }
 
+// RequiredIntArrayParam is a helper function that can be used to fetch a required integer array parameter from the request.
+// It does the following checks:
+// 1. Checks if the parameter is present in the request
+// 2. Checks if the parameter is an array and each element can be converted to int
+// 3. Checks if the array is not empty
+func RequiredIntArrayParam(r mcp.CallToolRequest, p string) ([]int, error) {
+	// Check if the parameter is present in the request
+	if _, ok := r.GetArguments()[p]; !ok {
+		return nil, fmt.Errorf("missing required parameter: %s", p)
+	}
+
+	switch v := r.GetArguments()[p].(type) {
+	case nil:
+		return nil, fmt.Errorf("missing required parameter: %s", p)
+	case []int:
+		if len(v) == 0 {
+			return nil, fmt.Errorf("parameter %s cannot be empty", p)
+		}
+		return v, nil
+	case []any:
+		if len(v) == 0 {
+			return nil, fmt.Errorf("parameter %s cannot be empty", p)
+		}
+		intSlice := make([]int, len(v))
+		for i, elem := range v {
+			switch num := elem.(type) {
+			case float64:
+				intSlice[i] = int(num)
+			case int:
+				intSlice[i] = num
+			case int32:
+				intSlice[i] = int(num)
+			case int64:
+				intSlice[i] = int(num)
+			default:
+				return nil, fmt.Errorf("parameter %s contains non-numeric value, element %d is %T", p, i, elem)
+			}
+		}
+		return intSlice, nil
+	default:
+		return nil, fmt.Errorf("parameter %s is not an array, is %T", p, r.GetArguments()[p])
+	}
+}
+
 // OptionalParam is a helper function that can be used to fetch a requested parameter from the request.
 // It does the following checks:
 // 1. Checks if the parameter is present in the request, if not, it returns its zero-value

pkg/github/server_test.go

@@ -564,6 +564,110 @@ func TestOptionalIntArrayParam(t *testing.T) {
 	}
 }
 
+func TestRequiredIntArrayParam(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      map[string]interface{}
+		paramName   string
+		expected    []int
+		expectError bool
+	}{
+		{
+			name:        "parameter not in request",
+			params:      map[string]any{},
+			paramName:   "numbers",
+			expected:    nil,
+			expectError: true,
+		},
+		{
+			name: "valid any array parameter with float64",
+			params: map[string]any{
+				"numbers": []any{float64(1), float64(2), float64(3)},
+			},
+			paramName:   "numbers",
+			expected:    []int{1, 2, 3},
+			expectError: false,
+		},
+		{
+			name: "valid int array parameter",
+			params: map[string]any{
+				"numbers": []int{1, 2, 3},
+			},
+			paramName:   "numbers",
+			expected:    []int{1, 2, 3},
+			expectError: false,
+		},
+		{
+			name: "mixed numeric types",
+			params: map[string]any{
+				"numbers": []any{float64(1), int(2), int32(3), int64(4)},
+			},
+			paramName:   "numbers",
+			expected:    []int{1, 2, 3, 4},
+			expectError: false,
+		},
+		{
+			name: "invalid type in array",
+			params: map[string]any{
+				"numbers": []any{float64(1), "not a number"},
+			},
+			paramName:   "numbers",
+			expected:    nil,
+			expectError: true,
+		},
+		{
+			name: "nil value",
+			params: map[string]any{
+				"numbers": nil,
+			},
+			paramName:   "numbers",
+			expected:    nil,
+			expectError: true,
+		},
+		{
+			name: "empty array",
+			params: map[string]any{
+				"numbers": []any{},
+			},
+			paramName:   "numbers",
+			expected:    nil,
+			expectError: true,
+		},
+		{
+			name: "empty int array",
+			params: map[string]any{
+				"numbers": []int{},
+			},
+			paramName:   "numbers",
+			expected:    nil,
+			expectError: true,
+		},
+		{
+			name: "wrong parameter type",
+			params: map[string]any{
+				"numbers": "not an array",
+			},
+			paramName:   "numbers",
+			expected:    nil,
+			expectError: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			request := createMCPRequest(tc.params)
+			result, err := RequiredIntArrayParam(request, tc.paramName)
+
+			if tc.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tc.expected, result)
+			}
+		})
+	}
+}
+
 func TestOptionalPaginationParams(t *testing.T) {
 	tests := []struct {
 		name        string