feat(cli): implement json, json-pretty, and summary reporters

The CLI advertised these as valid --reporter values but they were not
implemented, causing an error when used. Adds the three missing reporter
variants with snapshot tests.

JSON output shape aligned with Biome: summary object with numeric nanos
duration, per-diagnostic message/category/location, command field, and
zero-span fallback when source location is unavailable.

Summary reporter reuses ConsoleTraversalSummary from terminal reporter
and groups diagnostics by file with per-file error/warning counts.

Closes #694

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: psteinroe

crates/pgls_cli/src/cli_options.rs

@@ -129,6 +129,12 @@ pub enum CliReporter {
     Junit,
     /// Reports linter diagnostics using the [GitLab Code Quality report](https://docs.gitlab.com/ee/ci/testing/code_quality.html#implement-a-custom-tool).
     GitLab,
+    /// Diagnostics are printed as JSON
+    Json,
+    /// Diagnostics are printed as pretty-printed JSON
+    JsonPretty,
+    /// Only a summary of diagnostics is printed (counts, no individual diagnostics)
+    Summary,
 }
 
 impl CliReporter {
@@ -145,6 +151,9 @@ impl FromStr for CliReporter {
             "github" => Ok(Self::GitHub),
             "junit" => Ok(Self::Junit),
             "gitlab" => Ok(Self::GitLab),
+            "json" => Ok(Self::Json),
+            "json-pretty" => Ok(Self::JsonPretty),
+            "summary" => Ok(Self::Summary),
             _ => Err(format!(
                 "value {s:?} is not valid for the --reporter argument"
             )),
@@ -159,6 +168,9 @@ impl Display for CliReporter {
             CliReporter::GitHub => f.write_str("github"),
             CliReporter::Junit => f.write_str("junit"),
             CliReporter::GitLab => f.write_str("gitlab"),
+            CliReporter::Json => f.write_str("json"),
+            CliReporter::JsonPretty => f.write_str("json-pretty"),
+            CliReporter::Summary => f.write_str("summary"),
         }
     }
 }

crates/pgls_cli/src/reporter/json.rs

@@ -0,0 +1,166 @@
+use crate::diagnostics::CliDiagnostic;
+use crate::reporter::{Report, ReportConfig, ReportWriter};
+use pgls_console::{Console, ConsoleExt, markup};
+use pgls_diagnostics::display::SourceFile;
+use pgls_diagnostics::{Error, PrintDescription, Resource, Severity};
+use serde::Serialize;
+
+pub(crate) struct JsonReportWriter {
+    pub pretty: bool,
+}
+
+impl ReportWriter for JsonReportWriter {
+    fn write(
+        &mut self,
+        console: &mut dyn Console,
+        command_name: &str,
+        report: &Report,
+        config: &ReportConfig,
+    ) -> Result<(), CliDiagnostic> {
+        let diagnostics: Vec<_> = report
+            .diagnostics
+            .iter()
+            .filter(|d| d.severity() >= config.diagnostic_level)
+            .filter(|d| {
+                if d.tags().is_verbose() {
+                    config.verbose
+                } else {
+                    true
+                }
+            })
+            .map(to_json_report)
+            .collect();
+
+        let summary = JsonSummary::from_report(report);
+
+        let output = JsonOutput {
+            summary,
+            diagnostics,
+            command: command_name.to_string(),
+        };
+
+        let serialized = if self.pretty {
+            serde_json::to_string_pretty(&output)
+        } else {
+            serde_json::to_string(&output)
+        }
+        .map_err(|e| CliDiagnostic::io_error(std::io::Error::new(std::io::ErrorKind::Other, e)))?;
+
+        console.log(markup!({ serialized }));
+        Ok(())
+    }
+}
+
+#[derive(Serialize)]
+struct JsonOutput {
+    summary: JsonSummary,
+    diagnostics: Vec<JsonDiagnostic>,
+    command: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct JsonSummary {
+    changed: usize,
+    unchanged: usize,
+    duration: u128,
+    errors: u32,
+    warnings: u32,
+    skipped: usize,
+    skipped_diagnostics: u32,
+}
+
+impl JsonSummary {
+    fn from_report(report: &Report) -> Self {
+        let (changed, unchanged, skipped) = report
+            .traversal
+            .as_ref()
+            .map(|t| (t.changed, t.unchanged, t.skipped))
+            .unwrap_or_default();
+        Self {
+            changed,
+            unchanged,
+            duration: report.duration.as_nanos(),
+            errors: report.errors,
+            warnings: report.warnings,
+            skipped,
+            skipped_diagnostics: report.skipped_diagnostics,
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct JsonDiagnostic {
+    severity: &'static str,
+    message: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    category: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    location: Option<JsonLocation>,
+}
+
+#[derive(Serialize)]
+struct JsonLocation {
+    path: String,
+    start: JsonPosition,
+    end: JsonPosition,
+}
+
+#[derive(Serialize)]
+struct JsonPosition {
+    line: usize,
+    column: usize,
+}
+
+fn to_json_report(diagnostic: &Error) -> JsonDiagnostic {
+    let message = PrintDescription(diagnostic).to_string();
+    let category = diagnostic.category().map(|c| c.name().to_string());
+    let severity = match diagnostic.severity() {
+        Severity::Hint => "hint",
+        Severity::Information => "info",
+        Severity::Warning => "warning",
+        Severity::Error => "error",
+        Severity::Fatal => "fatal",
+    };
+
+    let location = to_location(diagnostic);
+
+    JsonDiagnostic {
+        severity,
+        message,
+        category,
+        location,
+    }
+}
+
+fn to_location(diagnostic: &Error) -> Option<JsonLocation> {
+    let loc = diagnostic.location();
+    let path = match loc.resource {
+        Some(Resource::File(file)) => file.to_string(),
+        _ => return None,
+    };
+
+    match (loc.span, loc.source_code) {
+        (Some(span), Some(source_code)) => {
+            let source = SourceFile::new(source_code);
+            let start = source.location(span.start()).ok()?;
+            let end = source.location(span.end()).ok()?;
+            Some(JsonLocation {
+                path,
+                start: JsonPosition {
+                    line: start.line_number.get(),
+                    column: start.column_number.get(),
+                },
+                end: JsonPosition {
+                    line: end.line_number.get(),
+                    column: end.column_number.get(),
+                },
+            })
+        }
+        _ => Some(JsonLocation {
+            path,
+            start: JsonPosition { line: 0, column: 0 },
+            end: JsonPosition { line: 0, column: 0 },
+        }),
+    }
+}

crates/pgls_cli/src/reporter/mod.rs

@@ -1,6 +1,8 @@
 pub(crate) mod github;
 pub(crate) mod gitlab;
+pub(crate) mod json;
 pub(crate) mod junit;
+pub(crate) mod summary;
 pub(crate) mod terminal;
 
 use crate::cli_options::{CliOptions, CliReporter};
@@ -39,6 +41,9 @@ pub enum ReportMode {
     GitHub,
     GitLab,
     Junit,
+    Json,
+    JsonPretty,
+    Summary,
 }
 
 impl From<CliReporter> for ReportMode {
@@ -48,6 +53,9 @@ impl From<CliReporter> for ReportMode {
             CliReporter::GitHub => Self::GitHub,
             CliReporter::Junit => Self::Junit,
             CliReporter::GitLab => Self::GitLab,
+            CliReporter::Json => Self::Json,
+            CliReporter::JsonPretty => Self::JsonPretty,
+            CliReporter::Summary => Self::Summary,
         }
     }
 }
@@ -129,6 +137,9 @@ impl Reporter {
             ReportMode::GitHub => Box::new(github::GithubReportWriter),
             ReportMode::GitLab => Box::new(gitlab::GitLabReportWriter),
             ReportMode::Junit => Box::new(junit::JunitReportWriter),
+            ReportMode::Json => Box::new(json::JsonReportWriter { pretty: false }),
+            ReportMode::JsonPretty => Box::new(json::JsonReportWriter { pretty: true }),
+            ReportMode::Summary => Box::new(summary::SummaryReportWriter),
         };
 
         writer.write(console, command_name, payload, &self.config)

crates/pgls_cli/src/reporter/summary.rs

@@ -0,0 +1,117 @@
+use crate::diagnostics::CliDiagnostic;
+use crate::reporter::terminal::{ConsoleDiagnosticSummary, ConsoleTraversalSummary};
+use crate::reporter::{Report, ReportConfig, ReportWriter};
+use pgls_console::fmt::{Display, Formatter};
+use pgls_console::{Console, ConsoleExt, markup};
+use pgls_diagnostics::{Error, Resource, Severity};
+use std::collections::BTreeMap;
+
+pub(crate) struct SummaryReportWriter;
+
+impl ReportWriter for SummaryReportWriter {
+    fn write(
+        &mut self,
+        console: &mut dyn Console,
+        command_name: &str,
+        report: &Report,
+        config: &ReportConfig,
+    ) -> Result<(), CliDiagnostic> {
+        let file_diagnostics = collect_file_diagnostics(report, config);
+        if !file_diagnostics.0.is_empty() {
+            console.log(markup! {{ file_diagnostics }});
+        }
+
+        if let Some(traversal) = &report.traversal {
+            console.log(markup! {
+                {ConsoleTraversalSummary(command_name, report, traversal)}
+            });
+        } else {
+            console.log(markup! {
+                {ConsoleDiagnosticSummary(command_name, report)}
+            });
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+struct DiagnosticCounts {
+    errors: usize,
+    warnings: usize,
+}
+
+impl DiagnosticCounts {
+    fn track(&mut self, severity: Severity) {
+        match severity {
+            Severity::Error | Severity::Fatal => self.errors += 1,
+            Severity::Warning => self.warnings += 1,
+            _ => {}
+        }
+    }
+}
+
+struct FileDiagnostics(BTreeMap<String, DiagnosticCounts>);
+
+fn collect_file_diagnostics(report: &Report, config: &ReportConfig) -> FileDiagnostics {
+    let mut files: BTreeMap<String, DiagnosticCounts> = BTreeMap::new();
+
+    for diagnostic in &report.diagnostics {
+        if !should_emit(config, diagnostic) {
+            continue;
+        }
+
+        let path = match diagnostic.location().resource {
+            Some(Resource::File(p)) => p.to_string(),
+            _ => continue,
+        };
+
+        files.entry(path).or_default().track(diagnostic.severity());
+    }
+
+    FileDiagnostics(files)
+}
+
+fn should_emit(config: &ReportConfig, diagnostic: &Error) -> bool {
+    if diagnostic.severity() < config.diagnostic_level {
+        return false;
+    }
+
+    if diagnostic.tags().is_verbose() {
+        config.verbose
+    } else {
+        true
+    }
+}
+
+impl Display for FileDiagnostics {
+    fn fmt(&self, fmt: &mut Formatter) -> std::io::Result<()> {
+        for (path, counts) in &self.0 {
+            fmt.write_str(path)?;
+            fmt.write_str(": ")?;
+
+            let mut parts = Vec::new();
+            if counts.errors > 0 {
+                parts.push(format!(
+                    "{} {}",
+                    counts.errors,
+                    if counts.errors == 1 { "error" } else { "errors" }
+                ));
+            }
+            if counts.warnings > 0 {
+                parts.push(format!(
+                    "{} {}",
+                    counts.warnings,
+                    if counts.warnings == 1 {
+                        "warning"
+                    } else {
+                        "warnings"
+                    }
+                ));
+            }
+            fmt.write_str(&parts.join(", "))?;
+            fmt.write_str("\n")?;
+        }
+        Ok(())
+    }
+}

crates/pgls_cli/src/reporter/terminal.rs

@@ -130,7 +130,7 @@ impl fmt::Display for SummaryDetail {
     }
 }
 
-struct ConsoleTraversalSummary<'a>(&'a str, &'a Report, &'a TraversalData);
+pub(crate) struct ConsoleTraversalSummary<'a>(pub &'a str, pub &'a Report, pub &'a TraversalData);
 
 impl fmt::Display for ConsoleTraversalSummary<'_> {
     fn fmt(&self, fmt: &mut Formatter) -> std::io::Result<()> {
@@ -168,7 +168,7 @@ impl fmt::Display for ConsoleTraversalSummary<'_> {
     }
 }
 
-struct ConsoleDiagnosticSummary<'a>(&'a str, &'a Report);
+pub(crate) struct ConsoleDiagnosticSummary<'a>(pub &'a str, pub &'a Report);
 
 impl fmt::Display for ConsoleDiagnosticSummary<'_> {
     fn fmt(&self, fmt: &mut Formatter) -> std::io::Result<()> {