Use slurp mode:

  o   --slurp/-s:

      Instead of running the filter for each JSON object
      in the input, read the entire input stream into a large
      array and run the filter just once.

$ jq -s '.' < tmp.json
[
  {
    "name": "John",
    "email": "[email protected]"
  },
  {
    "name": "Brad",
    "email": "[email protected]"
  }
]

There are two main ways to create a valid JSON array from arbitrary lists of strings. One is using jq with its --args option:

jq -c -n '$ARGS.positional' --args "${mylist[@]}"

or, if the elements are not to be encoded as strings (they may be plain numbers, for example, or previously prepared JSON strings or whole JSON objects),

jq -c -n '$ARGS.positional' --jsonargs "${mylist[@]}"

Note that --args and --jsonargs and its arguments need to be the last thing on the command line of jq.

I'm using -n to disable reading any external input and -c to create JSON in the "compact" output format, as shown in the question.

The other way is using jo, a tool specifically made to make it easy to generate JSON on the command line:

jo -a "${mylist[@]}"

The -a option to jo generates an array from the given arguments.

The jo tool infers the type of the object itself, so a list like

mylist=(1 2 3 4 5 b)

would be turned into the JSON array

[1,2,3,4,5,"b"]

This trick with the jq 1.5 inputs streaming filter seems to do it

... | jq -n '.items |= [inputs]'

Ex.

$ find ~/ -maxdepth 1 -name "D*" | 
    while read line; do 
      jq -n --arg name "$(basename "$line")" \
            --arg path "$line" \
        '{name: $name, path: $path}'
    done | jq -n '.items |= [inputs]'
{
  "items": [
    {
      "name": "Downloads",
      "path": "/home/steeldriver/Downloads"
    },
    {
      "name": "Desktop",
      "path": "/home/steeldriver/Desktop"
    },
    {
      "name": "Documents",
      "path": "/home/steeldriver/Documents"
    }
  ]
}

The -r option should not be used if the output will be fed into another JSON parser; only the last jq in the pipeline should use it – otherwise you risk feeding non-JSON data into the second jq instance.

Your last example with .[0].t seems correct and works with jq 1.6.

$ cat json | jq '.tx' | jq -r '.[0].t'
t for a

But this can be simplified to a single jq invocation, first incrementally to:

$ cat json | jq -r '.tx | .[0].t'
t for a

and then finally to:

$ cat json | jq -r '.tx[0].t'
t for a

Evidently one of the items in the array is a string. If your jq supports "?", then one possibility would be to use it:

.response[].text?

Another would be to check the type explicitly, e.g.:

.response[] | objects | .text

Yet another possibility:

.response[] | select(type=="object" and has("text")) | .text

If you want to have a placeholder value when there is no "text" field:

 .response[] | if type=="object" and has("text") then .text else null end

So it really depends on your requirements and perhaps the version of jq that you are using.