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.

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

jq has a filter, @csv, for converting an array to a CSV string. This filter takes into account most of the complexities associated with the CSV format, beginning with commas embedded in fields. (jq 1.5 has a similar filter, @tsv, for generating tab-separated-value files.)

Of course, if the headers and values are all guaranteed to be free of commas and double quotation marks, then there may be no need to use the @csv filter. Otherwise, it would probably be better to use it.

For example, if the 'Company Name' were 'Smith, Smith and Smith', and if the other values were as shown below, invoking jq with the "-r" option would produce valid CSV:

$ jq -r '.data | map(.displayName), map(.value) | @csv' so.json2csv.json
"First Name","Last Name","Position","Company Name","Country"
"John (""Johnnie"")","Doe","Director, Planning and Posterity","Smith, Smith and Smith","Transylvania"

Use @tsv to generated tab-separated values as output:

Copyjq -r '[.user, .cmd] | @tsv' <yourfile

...emits, given your input file:

Copyalex    echo '123'
john    echo '456'
alex    echo '789'

...though if you're filtering for only your user account, you can just print cmd directly, since the user value is known:

Copyjq -r 'select(.user == "alex") | .cmd' 

Here is an approach using some sample code and data from my answer to a similar question on Stack Overflow.

To choose multiple fields you can use Object Construction. E.g this filter makes an object containing just PublicDnsName and VpcId from each instance:

  .Reservations[]
| .Instances[]
| {PublicDnsName, VpcId}

If this filter is in filter.jq and the sample data from that other answer is in data.json then running

$ jq -M -f filter.jq data.json

produces

{
  "PublicDnsName": "xxxxxxxx",
  "VpcId": "vpc-eb09eb8e"
}

Once you have objects containing what you want getting the data into another format (e.g. csv) is easy. With this filter

  .Reservations[]
| .Instances[]
| {PublicDnsName, VpcId}
| [.[]]
| @csv

and the -r option

$ jq -M -r -f filter.jq data.json

jq produces

"xxxxxxxx","vpc-eb09eb8e"

To add a filtering condition, e.g. VpcId is not null, add a select.

  .Reservations[]
| .Instances[]
| {PublicDnsName, VpcId}
| select(.VpcId != null)
| [.[]]
| @csv

I recommend using String Interpolation:

jq '.users[] | "\(.first) \(.last)"'

We are piping down the result of .users[] to generate the string ".first .last" using string interpolation. \(foo) syntax is used for string interpolation in jq. So, for the above example, it becomes "Stevie Wonder" (".users[].first .users[].second" working elementwise) and "Michael Jackson".

jq reference: String interpolation

Do it in jq, but see @Kusalananda's answer first

jq -r '.host_components[].HostRoles.host_name | join(",")'

No, that's wrong. This is what you need:

jq -r '.host_components | map(.HostRoles.host_name) | join(",")'

Demo:

jq -r '.host_components | map(.HostRoles.host_name) | join(",")' <<DATA
{"host_components":[
  {"HostRoles":{"host_name":"one"}},
  {"HostRoles":{"host_name":"two"}},
  {"HostRoles":{"host_name":"three"}}
]}
DATA

outputs

one,two,three

Quick jq lesson
===========

jq filters are applied like this:
jq -r '.name_of_json_field_0 <optional filter>, .name_of_json_field_1 <optional filter>'
and so on and so forth. A single dot is the simplest filter; it leaves the data field untouched.

jq -r '.name_of_field .'

You may also leave the filter field untouched for the same effect. In your case: jq -r '.name, .description' will extract the values of both those fields.

.[] will unwrap an array to have the next piped filter applied to each unwrapped value. Example:
jq -r '.attributes | .[]
extracts all trait_types objects.

You may sometime want to repackage objects in an array by surrounding the filter in brackets:
jq -r '[.name, .description, .date]

You may sometime want to repackage data in an object by surrounding the filter in curly braces:
`jq -r '{new_field_name: .name, super_new_field_name: .description}'

playing around with these, I was able to get

jq -r '[.name, .description, .date, (.attributes | [.[] | .trait_type] | @csv | gsub(",";";") | gsub("\"";"")), (.attributes | [.[] | .value] | .[]] | @csv | gsub(",";";") | gsub("\"";""))] | @csv'

to give us:
"My Collection","This is a great collection.",1639717379161,"Background;Skin;Mouth;Eyes","Sand;Dark Brown;Smile Basic;Confused"

Name, description, and date were left as is, so let's break down the weird parts, one step at a time.

.attributes | [.[] | .trait_type]
.[] extracts each element of the attributes array and pipes the result of that into the next filter, which says to simply extract trait_type, where they are re-packaged in an array.

.attributes | [.[] | .trait_type] | @csv
turn the array into a csv-parsable format.

(.attributes | [.[] | .trait_type] | @csv | gsub(",";";") | gsub("\"";""))
Parens separate this from the rest of the evaluations, obviously. The first gsub here replaces commas with semicolons so they don't get interpreted as a separate field, the second removes all extra double quotes.

If you know the two column names anyway, you could simply extract them directly using .name and .version:

<file jq -r '["name", "version"], (.[] | [.name, .version]) | @csv'

You can also use your $cols variable, so the names only appear once:

<file jq -r '["name", "version"] as $cols | $cols, (.[] | [.[$cols[]]]) | @csv'

Or import them dynamically, e.g. using --args:

<file jq -r '$ARGS.positional, (.[] | [.[$ARGS.positional[]]]) | @csv' \
  --args name version

Output:

"name","version"
"foo","1.24"
"bar","1.21"
"boo","1.23"
"far","1.24"