Implement json output format option

Provides a schema to describe the output format.

Co-authored-by: Ivy Evans <ivy.evans@gusto.com>

Author: martinemde

schema/check-output.json

@@ -0,0 +1,83 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "pks check JSON output",
+  "type": "object",
+  "required": ["violations", "stale_todos", "summary"],
+  "additionalProperties": false,
+  "properties": {
+    "violations": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/Violation" }
+    },
+    "stale_todos": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/StaleTodo" }
+    },
+    "summary": {
+      "type": "object",
+      "required": [
+        "violation_count",
+        "stale_todo_count",
+        "strict_violation_count",
+        "success"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "violation_count": { "type": "integer", "minimum": 0 },
+        "stale_todo_count": { "type": "integer", "minimum": 0 },
+        "strict_violation_count": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Count of violations where strict=true (subset of violation_count)"
+        },
+        "success": { "type": "boolean" }
+      }
+    }
+  },
+  "$defs": {
+    "ViolationType": {
+      "type": "string",
+      "enum": ["dependency", "privacy", "visibility", "layer", "folder_privacy"]
+    },
+    "Violation": {
+      "type": "object",
+      "required": [
+        "violation_type",
+        "file",
+        "constant_name",
+        "referencing_pack_name",
+        "defining_pack_name",
+        "strict",
+        "message"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "violation_type": { "$ref": "#/$defs/ViolationType" },
+        "file": { "type": "string" },
+        "constant_name": { "type": "string" },
+        "referencing_pack_name": { "type": "string" },
+        "defining_pack_name": { "type": "string" },
+        "strict": { "type": "boolean" },
+        "message": { "type": "string" }
+      }
+    },
+    "StaleTodo": {
+      "type": "object",
+      "required": [
+        "violation_type",
+        "file",
+        "constant_name",
+        "referencing_pack_name",
+        "defining_pack_name"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "violation_type": { "$ref": "#/$defs/ViolationType" },
+        "file": { "type": "string" },
+        "constant_name": { "type": "string" },
+        "referencing_pack_name": { "type": "string" },
+        "defining_pack_name": { "type": "string" }
+      }
+    }
+  }
+}

src/packs.rs

@@ -11,6 +11,7 @@ pub(crate) mod configuration;
 pub(crate) mod constant_resolver;
 pub(crate) mod creator;
 pub(crate) mod csv;
+pub(crate) mod json;
 pub(crate) mod dependencies;
 pub(crate) mod ignored;
 pub(crate) mod monkey_patch_detection;
@@ -86,6 +87,9 @@ pub fn check(
         OutputFormat::CSV => {
             csv::write_csv(&result, std::io::stdout())?;
         }
+        OutputFormat::JSON => {
+            json::write_json(&result, std::io::stdout())?;
+        }
     }
 
     Ok(())

src/packs/cli.rs

@@ -159,6 +159,7 @@ enum Command {
 pub enum OutputFormat {
     Packwerk,
     CSV,
+    JSON,
 }
 
 #[derive(Debug, Args)]

src/packs/json.rs

@@ -0,0 +1,100 @@
+use itertools::chain;
+use serde::Serialize;
+
+use super::checker::{build_strict_violation_message, CheckAllResult};
+
+#[derive(Serialize)]
+struct JsonOutput<'a> {
+    violations: Vec<JsonViolation<'a>>,
+    stale_todos: Vec<JsonStaleTodo<'a>>,
+    summary: JsonSummary,
+}
+
+#[derive(Serialize)]
+struct JsonViolation<'a> {
+    violation_type: &'a str,
+    file: &'a str,
+    constant_name: &'a str,
+    referencing_pack_name: &'a str,
+    defining_pack_name: &'a str,
+    strict: bool,
+    message: String,
+}
+
+#[derive(Serialize)]
+struct JsonStaleTodo<'a> {
+    violation_type: &'a str,
+    file: &'a str,
+    constant_name: &'a str,
+    referencing_pack_name: &'a str,
+    defining_pack_name: &'a str,
+}
+
+#[derive(Serialize)]
+struct JsonSummary {
+    violation_count: usize,
+    stale_todo_count: usize,
+    strict_violation_count: usize,
+    success: bool,
+}
+
+pub fn write_json<W: std::io::Write>(
+    result: &CheckAllResult,
+    writer: W,
+) -> anyhow::Result<()> {
+    let all_violations = chain!(
+        &result.reportable_violations,
+        &result.strict_mode_violations
+    );
+
+    let violations: Vec<JsonViolation> = all_violations
+        .map(|v| {
+            let message = if v.identifier.strict {
+                build_strict_violation_message(&v.identifier)
+            } else {
+                v.message.clone()
+            };
+            JsonViolation {
+                violation_type: &v.identifier.violation_type,
+                file: &v.identifier.file,
+                constant_name: &v.identifier.constant_name,
+                referencing_pack_name: &v.identifier.referencing_pack_name,
+                defining_pack_name: &v.identifier.defining_pack_name,
+                strict: v.identifier.strict,
+                message,
+            }
+        })
+        .collect();
+
+    let stale_todos: Vec<JsonStaleTodo> = result
+        .stale_violations
+        .iter()
+        .map(|v| JsonStaleTodo {
+            violation_type: &v.violation_type,
+            file: &v.file,
+            constant_name: &v.constant_name,
+            referencing_pack_name: &v.referencing_pack_name,
+            defining_pack_name: &v.defining_pack_name,
+        })
+        .collect();
+
+    let violation_count = violations.len();
+    let stale_todo_count = stale_todos.len();
+    let strict_violation_count = result.strict_mode_violations.len();
+    let success =
+        violation_count == 0 && stale_todo_count == 0 && strict_violation_count == 0;
+
+    let output = JsonOutput {
+        violations,
+        stale_todos,
+        summary: JsonSummary {
+            violation_count,
+            stale_todo_count,
+            strict_violation_count,
+            success,
+        },
+    };
+
+    serde_json::to_writer(writer, &output)?;
+    Ok(())
+}

tests/check_test.rs

@@ -406,3 +406,112 @@ fn test_check_contents_ignoring_recorded_violations(
     common::teardown();
     Ok(())
 }
+
+#[test]
+fn test_check_with_json_output_format_violations() -> Result<(), Box<dyn Error>> {
+    let output = Command::cargo_bin("pks")?
+        .arg("--project-root")
+        .arg("tests/fixtures/simple_app")
+        .arg("check")
+        .arg("-o")
+        .arg("json")
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+
+    let json_output: serde_json::Value =
+        serde_json::from_slice(&output).expect("Output should be valid JSON");
+
+    assert_eq!(json_output["summary"]["violation_count"], 2);
+    assert_eq!(json_output["summary"]["success"], false);
+
+    let violations = json_output["violations"].as_array().unwrap();
+    assert_eq!(violations.len(), 2);
+
+    for violation in violations {
+        assert!(violation["violation_type"].as_str().is_some());
+        assert!(violation["file"].as_str().is_some());
+        assert!(violation["constant_name"].as_str().is_some());
+        assert!(violation["referencing_pack_name"].as_str().is_some());
+        assert!(violation["defining_pack_name"].as_str().is_some());
+        assert!(violation["strict"].as_bool().is_some());
+        assert!(violation["message"].as_str().is_some());
+    }
+
+    let violation_types: Vec<&str> = violations
+        .iter()
+        .map(|v| v["violation_type"].as_str().unwrap())
+        .collect();
+    assert!(violation_types.contains(&"dependency"));
+    assert!(violation_types.contains(&"privacy"));
+
+    common::teardown();
+    Ok(())
+}
+
+#[test]
+fn test_check_with_json_output_format_stale_todos() -> Result<(), Box<dyn Error>> {
+    let output = Command::cargo_bin("pks")?
+        .arg("--project-root")
+        .arg("tests/fixtures/contains_stale_violations")
+        .arg("check")
+        .arg("-o")
+        .arg("json")
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+
+    let json_output: serde_json::Value =
+        serde_json::from_slice(&output).expect("Output should be valid JSON");
+
+    assert!(
+        json_output["summary"]["stale_todo_count"].as_i64().unwrap() > 0,
+        "Expected at least one stale todo"
+    );
+    assert_eq!(json_output["summary"]["success"], false);
+
+    let stale_todos = json_output["stale_todos"].as_array().unwrap();
+    assert!(!stale_todos.is_empty(), "Expected stale_todos array to be non-empty");
+
+    let stale_todo = &stale_todos[0];
+    assert!(stale_todo["violation_type"].as_str().is_some());
+    assert!(stale_todo["file"].as_str().is_some());
+    assert!(stale_todo["constant_name"].as_str().is_some());
+    assert!(stale_todo["referencing_pack_name"].as_str().is_some());
+    assert!(stale_todo["defining_pack_name"].as_str().is_some());
+
+    common::teardown();
+    Ok(())
+}
+
+#[test]
+fn test_check_with_json_output_format_empty() -> Result<(), Box<dyn Error>> {
+    let output = Command::cargo_bin("pks")?
+        .arg("--project-root")
+        .arg("tests/fixtures/contains_package_todo")
+        .arg("check")
+        .arg("-o")
+        .arg("json")
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+
+    let json_output: serde_json::Value =
+        serde_json::from_slice(&output).expect("Output should be valid JSON");
+
+    assert_eq!(json_output["summary"]["violation_count"], 0);
+    assert_eq!(json_output["summary"]["stale_todo_count"], 0);
+    assert_eq!(json_output["summary"]["strict_violation_count"], 0);
+    assert_eq!(json_output["summary"]["success"], true);
+    assert!(json_output["violations"].as_array().unwrap().is_empty());
+    assert!(json_output["stale_todos"].as_array().unwrap().is_empty());
+
+    common::teardown();
+    Ok(())
+}