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.

Closes #694

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

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,135 @@
+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(JsonDiagnostic::from_error)
+            .collect();
+
+        let output = JsonReport {
+            diagnostics,
+            errors: report.errors,
+            warnings: report.warnings,
+            duration: format!("{:?}", report.duration),
+        };
+
+        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 JsonReport {
+    diagnostics: Vec<JsonDiagnostic>,
+    errors: u32,
+    warnings: u32,
+    duration: String,
+}
+
+#[derive(Serialize)]
+struct JsonDiagnostic {
+    severity: &'static str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    category: Option<String>,
+    description: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    location: Option<JsonLocation>,
+}
+
+#[derive(Serialize)]
+struct JsonLocation {
+    path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    start: Option<JsonPosition>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    end: Option<JsonPosition>,
+}
+
+#[derive(Serialize)]
+struct JsonPosition {
+    line: usize,
+    column: usize,
+}
+
+impl JsonDiagnostic {
+    fn from_error(diagnostic: &Error) -> Self {
+        let description = 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 = Self::build_location(diagnostic);
+
+        Self {
+            severity,
+            category,
+            description,
+            location,
+        }
+    }
+
+    fn build_location(diagnostic: &Error) -> Option<JsonLocation> {
+        let loc = diagnostic.location();
+        let path = match loc.resource {
+            Some(Resource::File(file)) => file.to_string(),
+            _ => return None,
+        };
+
+        let (start, end) = match (loc.span, loc.source_code) {
+            (Some(span), Some(source_code)) => {
+                let source = SourceFile::new(source_code);
+                let start = source.location(span.start()).ok().map(|l| JsonPosition {
+                    line: l.line_number.get(),
+                    column: l.column_number.get(),
+                });
+                let end = source.location(span.end()).ok().map(|l| JsonPosition {
+                    line: l.line_number.get(),
+                    column: l.column_number.get(),
+                });
+                (start, end)
+            }
+            _ => (None, None),
+        };
+
+        Some(JsonLocation { path, start, end })
+    }
+}

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,43 @@
+use crate::diagnostics::CliDiagnostic;
+use crate::reporter::{Report, ReportConfig, ReportWriter};
+use pgls_console::{Console, ConsoleExt, markup};
+
+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 mut lines = Vec::new();
+
+        if let Some(traversal) = &report.traversal {
+            let total_files = traversal.changed + traversal.unchanged;
+            lines.push(format!(
+                "{command_name}: Checked {total_files} file(s) in {:?}.",
+                report.duration
+            ));
+            if traversal.changed > 0 {
+                lines.push(format!("Fixed {} file(s).", traversal.changed));
+            }
+            if traversal.skipped > 0 {
+                lines.push(format!("Skipped {} file(s).", traversal.skipped));
+            }
+        } else {
+            lines.push(format!(
+                "{command_name}: Completed in {:?}.",
+                report.duration
+            ));
+        }
+
+        lines.push(format!("Errors: {}", report.errors));
+        lines.push(format!("Warnings: {}", report.warnings));
+
+        let output = lines.join("\n");
+        console.log(markup!({ output }));
+        Ok(())
+    }
+}

crates/pgls_cli/tests/assert_check.rs

@@ -54,6 +54,45 @@ fn check_junit_reporter_snapshot() {
     ]));
 }
 
+#[test]
+#[cfg_attr(
+    target_os = "windows",
+    ignore = "snapshot expectations only validated on unix-like platforms"
+)]
+fn check_json_reporter_snapshot() {
+    assert_snapshot!(run_check(&[
+        "--reporter",
+        "json",
+        "tests/fixtures/test.sql"
+    ]));
+}
+
+#[test]
+#[cfg_attr(
+    target_os = "windows",
+    ignore = "snapshot expectations only validated on unix-like platforms"
+)]
+fn check_json_pretty_reporter_snapshot() {
+    assert_snapshot!(run_check(&[
+        "--reporter",
+        "json-pretty",
+        "tests/fixtures/test.sql"
+    ]));
+}
+
+#[test]
+#[cfg_attr(
+    target_os = "windows",
+    ignore = "snapshot expectations only validated on unix-like platforms"
+)]
+fn check_summary_reporter_snapshot() {
+    assert_snapshot!(run_check(&[
+        "--reporter",
+        "summary",
+        "tests/fixtures/test.sql"
+    ]));
+}
+
 #[test]
 #[cfg_attr(
     target_os = "windows",
@@ -120,8 +159,23 @@ fn normalize_durations(input: &str) -> String {
     let mut search_start = 0;
     while let Some(relative) = content[search_start..].find(" in ") {
         let start = search_start + relative + 4;
-        if let Some(end_rel) = content[start..].find('.') {
-            let end = start + end_rel;
+        // Find end of sentence period: scan for '.' that is followed by
+        // a non-digit (or EOL), skipping decimal points inside durations.
+        let rest = &content[start..];
+        let mut dot_search = 0;
+        let mut found_end = None;
+        while let Some(dot_rel) = rest[dot_search..].find('.') {
+            let dot_pos = dot_search + dot_rel;
+            let after_dot = dot_pos + 1;
+            if after_dot >= rest.len()
+                || !rest.as_bytes()[after_dot].is_ascii_digit()
+            {
+                found_end = Some(start + dot_pos);
+                break;
+            }
+            dot_search = after_dot;
+        }
+        if let Some(end) = found_end {
             if content[start..end].chars().any(|c| c.is_ascii_digit()) {
                 content.replace_range(start..end, "<duration>");
                 search_start = start + "<duration>".len() + 1;
@@ -147,6 +201,47 @@ fn normalize_durations(input: &str) -> String {
         }
     }
 
+    // Normalize JSON "duration":"..." and "duration": "..." fields
+    for json_dur_pat in &["\"duration\":\"", "\"duration\": \""] {
+        let mut json_search = 0;
+        while let Some(relative) = content[json_search..].find(json_dur_pat) {
+            let start = json_search + relative + json_dur_pat.len();
+            if let Some(end_rel) = content[start..].find('"') {
+                let end = start + end_rel;
+                content.replace_range(start..end, "<duration>");
+                json_search = start + "<duration>".len() + 1;
+            } else {
+                break;
+            }
+        }
+    }
+
+    // Normalize Rust Debug durations (e.g. "4.877792ms", "1.23s", "123µs", "123ns")
+    // used by summary reporter: "file(s) in 4.877ms." / "Completed in 4.877ms."
+    for prefix in &["file(s) in ", "Completed in "] {
+        let mut search = 0;
+        while let Some(relative) = content[search..].find(prefix) {
+            let start = search + relative + prefix.len();
+            // Find the end of the duration: digits, '.', and time unit suffix
+            let rest = &content[start..];
+            let dur_end = rest
+                .find(|c: char| !c.is_ascii_digit() && c != '.' && c != 'µ')
+                .unwrap_or(rest.len());
+            // Include trailing unit letters (m, s, n, etc.)
+            let after_digits = &rest[dur_end..];
+            let unit_end = after_digits
+                .find(|c: char| !c.is_ascii_lowercase())
+                .unwrap_or(after_digits.len());
+            let total_end = start + dur_end + unit_end;
+            if total_end > start {
+                content.replace_range(start..total_end, "<duration>");
+                search = start + "<duration>".len();
+            } else {
+                search = start + 1;
+            }
+        }
+    }
+
     content
 }