--json output

Author: cscheid

crates/qmd-syntax-helper/src/conversions/definition_lists.rs

@@ -192,7 +192,7 @@ impl Rule for DefinitionListConverter {
         "Convert definition lists to div-based format"
     }
 
-    fn check(&self, file_path: &Path, verbose: bool) -> Result<CheckResult> {
+    fn check(&self, file_path: &Path, verbose: bool) -> Result<Vec<CheckResult>> {
         let content = read_file(file_path)?;
         let lists = self.find_definition_lists(&content);
 
@@ -204,17 +204,22 @@ impl Rule for DefinitionListConverter {
             }
         }
 
-        Ok(CheckResult {
-            rule_name: self.name().to_string(),
-            file_path: file_path.to_string_lossy().to_string(),
-            has_issue: !lists.is_empty(),
-            issue_count: lists.len(),
-            message: if lists.is_empty() {
-                None
-            } else {
-                Some(format!("Found {} definition list(s)", lists.len()))
-            },
-        })
+        let mut results = Vec::new();
+        for list in lists {
+            results.push(CheckResult {
+                rule_name: self.name().to_string(),
+                file_path: file_path.to_string_lossy().to_string(),
+                has_issue: true,
+                issue_count: 1,
+                message: Some("Definition list found".to_string()),
+                location: Some(crate::rule::SourceLocation {
+                    row: list.start_line + 1, // Convert 0-indexed to 1-indexed
+                    column: 1,
+                }),
+            });
+        }
+
+        Ok(results)
     }
 
     fn convert(

crates/qmd-syntax-helper/src/conversions/div_whitespace.rs

@@ -64,10 +64,17 @@ impl DivWhitespaceConverter {
                 }
 
                 let json_str = error_messages.join("");
-                let errors: Vec<ParseError> =
-                    serde_json::from_str(&json_str).context("Failed to parse JSON error output")?;
 
-                Ok(errors)
+                // Try to parse as JSON array
+                match serde_json::from_str::<Vec<ParseError>>(&json_str) {
+                    Ok(errors) => Ok(errors),
+                    Err(_) => {
+                        // If parsing fails, the messages are likely plain text warnings/debug messages
+                        // rather than actual syntax errors. These don't indicate div whitespace issues,
+                        // so we can safely ignore them for this specific rule.
+                        Ok(Vec::new())
+                    }
+                }
             }
         }
     }
@@ -130,6 +137,29 @@ impl DivWhitespaceConverter {
         fix_positions
     }
 
+    /// Convert byte offset to row/column (1-indexed)
+    fn byte_offset_to_location(&self, content: &str, byte_offset: usize) -> crate::rule::SourceLocation {
+        let mut row = 1;
+        let mut column = 1;
+        let mut current_offset = 0;
+
+        for ch in content.chars() {
+            if current_offset >= byte_offset {
+                break;
+            }
+            current_offset += ch.len_utf8();
+
+            if ch == '\n' {
+                row += 1;
+                column = 1;
+            } else {
+                column += 1;
+            }
+        }
+
+        crate::rule::SourceLocation { row, column }
+    }
+
     /// Apply fixes to content by inserting spaces at specified positions
     fn apply_fixes(&self, content: &str, fix_positions: &[usize]) -> String {
         let mut result = String::with_capacity(content.len() + fix_positions.len());
@@ -220,7 +250,7 @@ impl Rule for DivWhitespaceConverter {
         "Fix div fences missing whitespace (:::{ -> ::: {)"
     }
 
-    fn check(&self, file_path: &Path, verbose: bool) -> Result<CheckResult> {
+    fn check(&self, file_path: &Path, verbose: bool) -> Result<Vec<CheckResult>> {
         let content = read_file(file_path)?;
         let errors = self.get_parse_errors(file_path)?;
         let fix_positions = self.find_div_whitespace_errors(&content, &errors);
@@ -236,20 +266,20 @@ impl Rule for DivWhitespaceConverter {
             }
         }
 
-        Ok(CheckResult {
-            rule_name: self.name().to_string(),
-            file_path: file_path.to_string_lossy().to_string(),
-            has_issue: !fix_positions.is_empty(),
-            issue_count: fix_positions.len(),
-            message: if fix_positions.is_empty() {
-                None
-            } else {
-                Some(format!(
-                    "Found {} div fence(s) needing whitespace fixes",
-                    fix_positions.len()
-                ))
-            },
-        })
+        let mut results = Vec::new();
+        for &pos in &fix_positions {
+            let location = self.byte_offset_to_location(&content, pos);
+            results.push(CheckResult {
+                rule_name: self.name().to_string(),
+                file_path: file_path.to_string_lossy().to_string(),
+                has_issue: true,
+                issue_count: 1,
+                message: Some("Div fence missing whitespace (:::{ should be ::: {)".to_string()),
+                location: Some(location),
+            });
+        }
+
+        Ok(results)
     }
 
     fn convert(

crates/qmd-syntax-helper/src/conversions/grid_tables.rs

@@ -153,7 +153,7 @@ impl Rule for GridTableConverter {
         "Convert grid tables to list-table format"
     }
 
-    fn check(&self, file_path: &Path, verbose: bool) -> Result<CheckResult> {
+    fn check(&self, file_path: &Path, verbose: bool) -> Result<Vec<CheckResult>> {
         let content = read_file(file_path)?;
         let tables = self.find_grid_tables(&content);
 
@@ -165,17 +165,22 @@ impl Rule for GridTableConverter {
             }
         }
 
-        Ok(CheckResult {
-            rule_name: self.name().to_string(),
-            file_path: file_path.to_string_lossy().to_string(),
-            has_issue: !tables.is_empty(),
-            issue_count: tables.len(),
-            message: if tables.is_empty() {
-                None
-            } else {
-                Some(format!("Found {} grid table(s)", tables.len()))
-            },
-        })
+        let mut results = Vec::new();
+        for table in tables {
+            results.push(CheckResult {
+                rule_name: self.name().to_string(),
+                file_path: file_path.to_string_lossy().to_string(),
+                has_issue: true,
+                issue_count: 1,
+                message: Some("Grid table found".to_string()),
+                location: Some(crate::rule::SourceLocation {
+                    row: table.start_line + 1, // Convert 0-indexed to 1-indexed
+                    column: 1,
+                }),
+            });
+        }
+
+        Ok(results)
     }
 
     fn convert(

crates/qmd-syntax-helper/src/diagnostics/mod.rs

@@ -1 +1,2 @@
+pub mod parse_check;
 // pub mod syntax_check; // Unused - kept for reference only

crates/qmd-syntax-helper/src/diagnostics/parse_check.rs

@@ -0,0 +1,82 @@
+use anyhow::{Context, Result};
+use std::fs;
+use std::path::Path;
+
+use crate::rule::{CheckResult, ConvertResult, Rule};
+
+pub struct ParseChecker {}
+
+impl ParseChecker {
+    pub fn new() -> Result<Self> {
+        Ok(Self {})
+    }
+
+    /// Check if a file parses successfully
+    fn check_parse(&self, file_path: &Path) -> Result<bool> {
+        let content = fs::read_to_string(file_path)
+            .with_context(|| format!("Failed to read file: {}", file_path.display()))?;
+
+        let mut sink = std::io::sink();
+        let filename = file_path.to_string_lossy();
+
+        let result = quarto_markdown_pandoc::readers::qmd::read(
+            content.as_bytes(),
+            false,
+            &filename,
+            &mut sink,
+            Some(
+                quarto_markdown_pandoc::readers::qmd_error_messages::produce_json_error_messages
+                    as fn(
+                        &[u8],
+                        &quarto_markdown_pandoc::utils::tree_sitter_log_observer::TreeSitterLogObserver,
+                        &str,
+                    ) -> Vec<String>,
+            ),
+        );
+
+        Ok(result.is_ok())
+    }
+}
+
+impl Rule for ParseChecker {
+    fn name(&self) -> &str {
+        "parse"
+    }
+
+    fn description(&self) -> &str {
+        "Check if file parses successfully"
+    }
+
+    fn check(&self, file_path: &Path, _verbose: bool) -> Result<Vec<CheckResult>> {
+        let parses = self.check_parse(file_path)?;
+
+        if parses {
+            Ok(vec![])
+        } else {
+            Ok(vec![CheckResult {
+                rule_name: self.name().to_string(),
+                file_path: file_path.to_string_lossy().to_string(),
+                has_issue: true,
+                issue_count: 1,
+                message: Some("File failed to parse".to_string()),
+                location: None, // Parse errors don't have specific locations
+            }])
+        }
+    }
+
+    fn convert(
+        &self,
+        file_path: &Path,
+        _in_place: bool,
+        _check_mode: bool,
+        _verbose: bool,
+    ) -> Result<ConvertResult> {
+        // Parse errors can't be auto-fixed
+        Ok(ConvertResult {
+            rule_name: self.name().to_string(),
+            file_path: file_path.to_string_lossy().to_string(),
+            fixes_applied: 0,
+            message: Some("Parse errors cannot be automatically fixed".to_string()),
+        })
+    }
+}

crates/qmd-syntax-helper/src/diagnostics/syntax_check.rs

@@ -71,13 +71,14 @@ impl SyntaxChecker {
             false, // not loose mode
             &filename,
             &mut sink,
-            None::<
-                fn(
-                    &[u8],
-                    &quarto_markdown_pandoc::utils::tree_sitter_log_observer::TreeSitterLogObserver,
-                    &str,
-                ) -> Vec<String>,
-            >, // no custom error formatter
+            Some(
+                quarto_markdown_pandoc::readers::qmd_error_messages::produce_json_error_messages
+                    as fn(
+                        &[u8],
+                        &quarto_markdown_pandoc::utils::tree_sitter_log_observer::TreeSitterLogObserver,
+                        &str,
+                    ) -> Vec<String>,
+            ), // Use JSON error formatter for machine-readable errors
         );
 
         match result {

crates/qmd-syntax-helper/src/main.rs

@@ -96,10 +96,12 @@ fn main() -> Result<()> {
 
                 for rule in &rules {
                     match rule.check(&file_path, verbose && !json) {
-                        Ok(result) => {
-                            all_results.push(result.clone());
-                            if !json && result.has_issue {
-                                println!("  {} {}", "✗".red(), result.message.unwrap_or_default());
+                        Ok(results) => {
+                            for result in results {
+                                all_results.push(result.clone());
+                                if !json && result.has_issue {
+                                    println!("  {} {}", "✗".red(), result.message.unwrap_or_default());
+                                }
                             }
                         }
                         Err(e) => {
@@ -111,6 +113,11 @@ fn main() -> Result<()> {
                 }
             }
 
+            // Print summary if not in JSON mode
+            if !json && !all_results.is_empty() {
+                print_check_summary(&all_results);
+            }
+
             // Output handling
             if json {
                 for result in &all_results {
@@ -202,3 +209,73 @@ fn resolve_rules(
         Ok(rules)
     }
 }
+
+fn print_check_summary(results: &[rule::CheckResult]) {
+    use std::collections::{HashMap, HashSet};
+
+    // Get unique files checked
+    let unique_files: HashSet<&str> = results.iter().map(|r| r.file_path.as_str()).collect();
+    let total_files = unique_files.len();
+
+    // Count files with issues (at least one result with has_issue=true)
+    let mut files_with_issues = HashSet::new();
+    let mut total_issues = 0;
+
+    // Track issues by rule type
+    let mut issues_by_rule: HashMap<String, usize> = HashMap::new();
+    let mut files_by_rule: HashMap<String, HashSet<String>> = HashMap::new();
+
+    for result in results {
+        if result.has_issue {
+            files_with_issues.insert(&result.file_path);
+            total_issues += result.issue_count;
+
+            // Track by rule
+            *issues_by_rule.entry(result.rule_name.clone()).or_insert(0) += result.issue_count;
+            files_by_rule
+                .entry(result.rule_name.clone())
+                .or_insert_with(HashSet::new)
+                .insert(result.file_path.clone());
+        }
+    }
+
+    let files_with_issues_count = files_with_issues.len();
+    let files_clean = total_files - files_with_issues_count;
+
+    println!("\n{}", "=== Summary ===".bold());
+    println!("Total files:         {}", total_files);
+    println!(
+        "Files with issues:   {} {}",
+        files_with_issues_count,
+        if files_with_issues_count > 0 {
+            "✗".red()
+        } else {
+            "✓".green()
+        }
+    );
+    println!("Clean files:         {} {}", files_clean, "✓".green());
+
+    if !issues_by_rule.is_empty() {
+        println!("\n{}", "Issues by rule:".bold());
+        let mut rule_names: Vec<_> = issues_by_rule.keys().collect();
+        rule_names.sort();
+
+        for rule_name in rule_names {
+            let count = issues_by_rule[rule_name];
+            let file_count = files_by_rule[rule_name].len();
+            println!(
+                "  {}: {} issue(s) in {} file(s)",
+                rule_name.cyan(),
+                count,
+                file_count
+            );
+        }
+    }
+
+    println!("\nTotal issues found:  {}", total_issues);
+
+    if total_files > 0 {
+        let success_rate = (files_clean as f64 / total_files as f64) * 100.0;
+        println!("Success rate:        {:.1}%", success_rate);
+    }
+}