Found the answer:

cat <file>.json | jq -r '.files[] | select(.fileName=="FOO") | .md5'

You want to run a .context,.score filter on each element of v I think:

$ jq -r '.[] | [.c, .e, .score, (.v[] | .context,.score)] | @csv' file.json
"A","B",0.99,"asdf",0.98,"bcdfd",0.97

This is equivalent to using the builtin map function without assembling the results back into an array.

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

You forgot to filter the compontents array when selecting for Redundant System ROM.

A corrected variant of your code with some shortcuts added (note that -r is unneeded as you are outputting JSON, not raw strings):

jq '.members[] |
    {
        serverName,
        "system-firmware":
            .components[] | select(.componentName == "System ROM").componentVersion,
        "system-firmware-backup":
            .components[] | select(.componentName == "Redundant System ROM").componentVersion
    }' file

Given the data in the question, this would give you the following JSON document:

{
  "serverName": "my-host",
  "system-firmware": "A46 v2.80 (07/31/2023)",
  "system-firmware-backup": "A46 v2.60 (08/11/20223)"
}

jq '.fields |= ( map(.key = .name | del(.type,.linkedId,.name)) | from_entries )' file

This updates the fields array. First, for each element (using map()), a key key is created with the value from the name key. Then the type, linkedId, and name keys are deleted from the element. We are now left with a key and a value key in each element of the fields array, which is just what from_entries needs to associate the key values as keys to the value values.

Testing on the data given in the question (with a trailing comma removed), this generates the following JSON:

{
  "name": "Papanito",
  "fields": {
    "Name1": "Value1",
    "Name2": "Value2",
    "Name3": "Value3",
    "Name4": "Value3"
  }
}

Note that your expected output is invalid JSON, as an array can't have keys. Therefore, the fields value in the output above is an object, not an array.

Would you want to keep fields as an array, you could rearrange the operations a bit:

jq '.fields |= map([.key = .name | del(.type,.linkedId,.name)] | from_entries)' file

For the given data (corrected as mentioned above), this would generate something equivalent to the following document:

{
   "name": "Papanito",
   "fields": [
      { "Name1": "Value1" },
      { "Name2": "Value2" },
      { "Name3": "Value3" },
      { "Name4": "Value3" }
   ]
}

This has the benefit that two elements with the same original name values would not overwrite each other in the result.

Conceptually, the above deletes the data that we no longer want. The following variations extract the data we want instead.

This generates the last result from above:

jq '.fields |= map({ (.name): .value })' file

And we can get the first result (with fields as a single object) by merging the entries in the list:

jq '.fields |= (map({ (.name): .value }) | add)' file

You can use jq '.[] | .login, .id' to obtain each login followed by its id.

Found out the answer

jq 'select(.items | index("blue"))'

A slightly different approach from what rowboat took:

jq 'map(select(any(contains("a"))))' file

The innermost test tests each of the strings for the substring a. If any string in a sub-array contains a, that sub-array is selected. The map applies the selection to all sub-arrays in the top-level array.

The result is a top-level array with sub-arrays that contain at least one element that contains the substring a:

[
  [
    "a",
    "b",
    "c"
  ],
  [
    "abc",
    "e",
    "f"
  ]
]