Print each jq output on its own line to match gh --jq behavior

Author: ilyazub

src/jq.rs

@@ -1,7 +1,7 @@
 use jaq_interpret::{Ctx, FilterT, ParseCtx, RcIter, Val};
 use serde_json::Value;
 
-pub fn apply(expression: &str, input: &Value) -> Result<Value, Box<dyn std::error::Error>> {
+pub fn apply(expression: &str, input: &Value) -> Result<Vec<Value>, Box<dyn std::error::Error>> {
     let mut defs = ParseCtx::new(Vec::new());
     defs.insert_natives(jaq_core::core());
     defs.insert_defs(jaq_std::std());
@@ -27,9 +27,5 @@ pub fn apply(expression: &str, input: &Value) -> Result<Value, Box<dyn std::erro
         .map(|v| v.map(Value::from).map_err(|e| format!("jq error: {:?}", e)))
         .collect::<Result<Vec<_>, _>>()?;
 
-    match out.len() {
-        0 => Ok(Value::Null),
-        1 => Ok(out.into_iter().next().unwrap()),
-        _ => Ok(Value::Array(out)),
-    }
+    Ok(out)
 }

src/main.rs

@@ -96,17 +96,29 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     match result {
         Ok(value) => {
-            let filtered = match cli.jq.as_deref() {
-                Some(expr) => jq::apply(expr, &value)?,
-                None => value,
-            };
-            output::print_json(&filtered, json_mode).map_err(|e| {
-                let err = error::CliError::ApiError {
-                    message: format!("Output error: {}", e),
-                };
-                error::print_error(&err);
-                std::process::exit(error::exit_code(&err));
-            }).ok();
+            match cli.jq.as_deref() {
+                Some(expr) => {
+                    let results = jq::apply(expr, &value)?;
+                    for v in &results {
+                        output::print_json(v, json_mode).map_err(|e| {
+                            let err = error::CliError::ApiError {
+                                message: format!("Output error: {}", e),
+                            };
+                            error::print_error(&err);
+                            std::process::exit(error::exit_code(&err));
+                        }).ok();
+                    }
+                }
+                None => {
+                    output::print_json(&value, json_mode).map_err(|e| {
+                        let err = error::CliError::ApiError {
+                            message: format!("Output error: {}", e),
+                        };
+                        error::print_error(&err);
+                        std::process::exit(error::exit_code(&err));
+                    }).ok();
+                }
+            }
         }
         Err(e) => {
             error::print_error(&e);

tests/integration_tests.rs

@@ -231,63 +231,70 @@ mod jq_tests {
     fn test_jq_identity() {
         let input = json!({"a": 1, "b": 2});
         let result = jq::apply(".", &input).unwrap();
-        assert_eq!(result, input);
+        assert_eq!(result, vec![input]);
     }
 
     #[test]
     fn test_jq_field_access() {
         let input = json!({"name": "test", "value": 42});
         let result = jq::apply(".name", &input).unwrap();
-        assert_eq!(result, json!("test"));
+        assert_eq!(result, vec![json!("test")]);
     }
 
     #[test]
     fn test_jq_nested_access() {
         let input = json!({"a": {"b": {"c": "deep"}}});
         let result = jq::apply(".a.b.c", &input).unwrap();
-        assert_eq!(result, json!("deep"));
+        assert_eq!(result, vec![json!("deep")]);
     }
 
     #[test]
     fn test_jq_array_index() {
         let input = json!({"items": ["a", "b", "c"]});
         let result = jq::apply(".items[0]", &input).unwrap();
-        assert_eq!(result, json!("a"));
+        assert_eq!(result, vec![json!("a")]);
     }
 
     #[test]
     fn test_jq_array_slice() {
         let input = json!({"items": [1, 2, 3, 4, 5]});
         let result = jq::apply(".items[0:3]", &input).unwrap();
-        assert_eq!(result, json!([1, 2, 3]));
+        assert_eq!(result, vec![json!([1, 2, 3])]);
     }
 
     #[test]
     fn test_jq_select_fields() {
         let input = json!({"name": "test", "age": 30, "extra": true});
         let result = jq::apply("{name, age}", &input).unwrap();
-        assert_eq!(result, json!({"name": "test", "age": 30}));
+        assert_eq!(result, vec![json!({"name": "test", "age": 30})]);
     }
 
     #[test]
     fn test_jq_pipe() {
         let input = json!({"items": [{"name": "a"}, {"name": "b"}]});
         let result = jq::apply(".items | length", &input).unwrap();
-        assert_eq!(result, json!(2));
+        assert_eq!(result, vec![json!(2)]);
     }
 
     #[test]
     fn test_jq_map() {
         let input = json!({"items": [{"name": "a", "v": 1}, {"name": "b", "v": 2}]});
         let result = jq::apply("[.items[] | .name]", &input).unwrap();
-        assert_eq!(result, json!(["a", "b"]));
+        assert_eq!(result, vec![json!(["a", "b"])]);
     }
 
     #[test]
     fn test_jq_null_on_missing() {
         let input = json!({"a": 1});
         let result = jq::apply(".nonexistent", &input).unwrap();
-        assert_eq!(result, json!(null));
+        assert_eq!(result, vec![json!(null)]);
+    }
+
+    #[test]
+    fn test_jq_multiple_outputs() {
+        let input = json!({"items": [{"name": "a"}, {"name": "b"}, {"name": "c"}]});
+        let result = jq::apply(".items[].name", &input).unwrap();
+        assert_eq!(result, vec![json!("a"), json!("b"), json!("c")]);
     }
 
     #[test]