Add spanned error reporting for eure-mark

- Add report.rs module with ErrorReports conversion
- Enhance ReferenceError with span information (NodeId, offset, len)
- Use CheckContext struct to simplify span-aware checking
- Update CLI to use format_check_errors for spanned error output
- Add test suite scenario for euremark_errors validation
- Add test cases for missing cite/ref errors

Author: claude

Cargo.lock

@@ -3,7 +3,7 @@
 use clap::{Parser, Subcommand};
 use eure::document::cst_to_document_and_origin_map;
 use eure::error::format_parse_error_color;
-use eure_mark::{check_references, EumdDocument};
+use eure_mark::{check_references_with_spans, format_check_errors, EumdDocument};
 
 use crate::util::{display_path, read_input};
 
@@ -40,18 +40,16 @@ fn run_check(args: CheckArgs) {
         }
     };
 
+    let path = display_path(args.file.as_deref());
     let parse_result = eure_parol::parse_tolerant(&contents);
 
     if let Some(error) = parse_result.error() {
-        eprintln!(
-            "{}",
-            format_parse_error_color(error, &contents, display_path(args.file.as_deref()))
-        );
+        eprintln!("{}", format_parse_error_color(error, &contents, path));
         std::process::exit(1);
     }
 
     let cst = parse_result.cst();
-    let (doc, _origin_map) = match cst_to_document_and_origin_map(&contents, &cst) {
+    let (doc, origin_map) = match cst_to_document_and_origin_map(&contents, &cst) {
         Ok(result) => result,
         Err(e) => {
             eprintln!("Error converting to document: {e}");
@@ -68,22 +66,15 @@ fn run_check(args: CheckArgs) {
         }
     };
 
-    let result = check_references(&eumd_doc);
+    // Use the span-aware check function
+    let result = check_references_with_spans(&eumd_doc, &doc);
 
     if result.is_ok() {
-        println!(
-            "\x1b[1;32m✓\x1b[0m {} references OK",
-            display_path(args.file.as_deref())
-        );
+        println!("\x1b[1;32m✓\x1b[0m {} references OK", path);
     } else {
-        eprintln!(
-            "\x1b[1;31m✗\x1b[0m {} has {} reference error(s):",
-            display_path(args.file.as_deref()),
-            result.errors.len()
-        );
-        for error in &result.errors {
-            eprintln!("  - {error}");
-        }
+        // Format errors with source spans using styled output
+        let formatted = format_check_errors(&result, &contents, path, &cst, &origin_map, true);
+        eprintln!("{formatted}");
         std::process::exit(1);
     }
 }

crates/eure-cli/src/commands/mark.rs

@@ -13,6 +13,7 @@ keywords = ["eure", "markdown", "document"]
 eure = { workspace = true }
 eure-document = { workspace = true }
 eure-parol = { workspace = true }
+eure-tree = { workspace = true }
 thiserror = { workspace = true }
 regex = { workspace = true }
 

crates/eure-mark/Cargo.toml

@@ -2,6 +2,7 @@
 
 use std::collections::HashSet;
 
+use eure_document::document::{EureDocument, NodeId};
 use eure_document::map::Map;
 use regex::Regex;
 use std::sync::LazyLock;
@@ -44,7 +45,7 @@ fn collect_section_keys(sections: &Map<String, Section>, keys: &mut HashSet<Stri
     }
 }
 
-/// Check all references in a document
+/// Check all references in a document (basic version without spans)
 pub fn check_references(doc: &EumdDocument) -> CheckResult {
     let mut result = CheckResult::default();
 
@@ -61,7 +62,7 @@ pub fn check_references(doc: &EumdDocument) -> CheckResult {
     collect_section_keys(&doc.sections, &mut section_keys);
 
     // Check references in all markdown content
-    check_content(
+    check_content_simple(
         doc.description.as_deref(),
         "in description",
         &cite_keys,
@@ -70,7 +71,7 @@ pub fn check_references(doc: &EumdDocument) -> CheckResult {
         &mut result,
     );
 
-    check_content(
+    check_content_simple(
         doc.intro.as_deref(),
         "in intro",
         &cite_keys,
@@ -80,7 +81,7 @@ pub fn check_references(doc: &EumdDocument) -> CheckResult {
     );
 
     // Check sections recursively
-    check_sections(
+    check_sections_simple(
         &doc.sections,
         "",
         &cite_keys,
@@ -91,7 +92,7 @@ pub fn check_references(doc: &EumdDocument) -> CheckResult {
 
     // Check footnote content
     for (key, footnote) in doc.footnotes.iter() {
-        check_content(
+        check_content_simple(
             Some(&footnote.content),
             &format!("in footnote '{key}'"),
             &cite_keys,
@@ -104,7 +105,7 @@ pub fn check_references(doc: &EumdDocument) -> CheckResult {
     result
 }
 
-fn check_content(
+fn check_content_simple(
     content: Option<&str>,
     location: &str,
     cite_keys: &HashSet<String>,
@@ -122,16 +123,16 @@ fn check_content(
         };
 
         if !is_valid {
-            result.errors.push(ReferenceError {
-                ref_type: reference.ref_type,
-                key: reference.key,
-                location: location.to_string(),
-            });
+            result.errors.push(ReferenceError::new(
+                reference.ref_type,
+                reference.key,
+                location.to_string(),
+            ));
         }
     }
 }
 
-fn check_sections(
+fn check_sections_simple(
     sections: &Map<String, Section>,
     path: &str,
     cite_keys: &HashSet<String>,
@@ -147,7 +148,7 @@ fn check_sections(
         };
 
         // Check header if present
-        check_content(
+        check_content_simple(
             section.header.as_deref(),
             &format!("in section '{current_path}' header"),
             cite_keys,
@@ -157,7 +158,7 @@ fn check_sections(
         );
 
         // Check body
-        check_content(
+        check_content_simple(
             section.body.as_deref(),
             &format!("in section '{current_path}'"),
             cite_keys,
@@ -167,7 +168,7 @@ fn check_sections(
         );
 
         // Recurse into nested sections
-        check_sections(
+        check_sections_simple(
             &section.sections,
             &current_path,
             cite_keys,
@@ -178,6 +179,182 @@ fn check_sections(
     }
 }
 
+// ============================================================================
+// Advanced checking with span information
+// ============================================================================
+
+/// Context for checking with span information
+struct CheckContext<'a> {
+    raw_doc: &'a EureDocument,
+    cite_keys: HashSet<String>,
+    footnote_keys: HashSet<String>,
+    section_keys: HashSet<String>,
+    result: CheckResult,
+}
+
+impl<'a> CheckContext<'a> {
+    fn new(eumd_doc: &EumdDocument, raw_doc: &'a EureDocument) -> Self {
+        let cite_keys: HashSet<String> = eumd_doc
+            .cites
+            .as_ref()
+            .map(|c| extract_bibtex_keys(c))
+            .unwrap_or_default();
+
+        let footnote_keys: HashSet<String> =
+            eumd_doc.footnotes.iter().map(|(k, _)| k.clone()).collect();
+
+        let mut section_keys = HashSet::new();
+        collect_section_keys(&eumd_doc.sections, &mut section_keys);
+
+        CheckContext {
+            raw_doc,
+            cite_keys,
+            footnote_keys,
+            section_keys,
+            result: CheckResult::default(),
+        }
+    }
+
+    fn check_content(&mut self, content: &str, location: &str, node_id: NodeId) {
+        // Get the actual text content offset within the code block
+        let content_offset = get_code_block_content_offset(self.raw_doc, node_id);
+
+        for reference in extract_references(content) {
+            let is_valid = match reference.ref_type {
+                ReferenceType::Cite => self.cite_keys.contains(&reference.key),
+                ReferenceType::Footnote => self.footnote_keys.contains(&reference.key),
+                ReferenceType::Section => self.section_keys.contains(&reference.key),
+            };
+
+            if !is_valid {
+                self.result.errors.push(ReferenceError::with_span(
+                    reference.ref_type,
+                    reference.key,
+                    location.to_string(),
+                    node_id,
+                    content_offset + reference.offset,
+                    reference.len,
+                ));
+            }
+        }
+    }
+
+    fn check_sections(
+        &mut self,
+        sections: &Map<String, Section>,
+        path: &str,
+        sections_node_id: NodeId,
+    ) {
+        let sections_node = self.raw_doc.node(sections_node_id);
+        let Some(sections_map) = sections_node.as_map() else {
+            return;
+        };
+
+        for (key, section) in sections.iter() {
+            let current_path = if path.is_empty() {
+                key.clone()
+            } else {
+                format!("{path}.{key}")
+            };
+
+            let Some(section_node_id) = sections_map.get_node_id(&key.clone().into()) else {
+                continue;
+            };
+
+            let section_node = self.raw_doc.node(section_node_id);
+            let Some(section_map) = section_node.as_map() else {
+                continue;
+            };
+
+            // Check header if present
+            if let Some(ref header) = section.header
+                && let Some(header_node_id) = section_map.get_node_id(&"header".into())
+            {
+                self.check_content(
+                    header,
+                    &format!("in section '{current_path}' header"),
+                    header_node_id,
+                );
+            }
+
+            // Check body
+            if let Some(ref body) = section.body
+                && let Some(body_node_id) = section_map.get_node_id(&"body".into())
+            {
+                self.check_content(body, &format!("in section '{current_path}'"), body_node_id);
+            }
+
+            // Recurse into nested sections
+            if let Some(nested_sections_id) = section_map.get_node_id(&"sections".into()) {
+                self.check_sections(&section.sections, &current_path, nested_sections_id);
+            }
+        }
+    }
+}
+
+/// Get the byte offset of the code block content start within the node
+fn get_code_block_content_offset(_raw_doc: &EureDocument, _node_id: NodeId) -> u32 {
+    // For code blocks, we need to account for the opening ``` and language tag
+    // However, since we're using the node's span which points to the content,
+    // we can return 0 here. The actual offset calculation happens in report.rs
+    // when we compute the final span using OriginMap.
+    0
+}
+
+/// Check references with span information for better error reporting
+pub fn check_references_with_spans(eumd_doc: &EumdDocument, raw_doc: &EureDocument) -> CheckResult {
+    let mut ctx = CheckContext::new(eumd_doc, raw_doc);
+
+    let root_id = raw_doc.get_root_id();
+    let root = raw_doc.node(root_id);
+
+    let Some(map) = root.as_map() else {
+        return ctx.result;
+    };
+
+    // Check description
+    if let Some(ref content) = eumd_doc.description
+        && let Some(node_id) = map.get_node_id(&"description".into())
+    {
+        ctx.check_content(content, "in description", node_id);
+    }
+
+    // Check intro
+    if let Some(ref content) = eumd_doc.intro
+        && let Some(node_id) = map.get_node_id(&"intro".into())
+    {
+        ctx.check_content(content, "in intro", node_id);
+    }
+
+    // Check sections recursively
+    if let Some(sections_node_id) = map.get_node_id(&"sections".into()) {
+        ctx.check_sections(&eumd_doc.sections, "", sections_node_id);
+    }
+
+    // Check footnotes
+    if let Some(footnotes_node_id) = map.get_node_id(&"footnotes".into()) {
+        let footnotes_node = raw_doc.node(footnotes_node_id);
+        if let Some(footnotes_map) = footnotes_node.as_map() {
+            for (key, footnote) in eumd_doc.footnotes.iter() {
+                if let Some(footnote_node_id) = footnotes_map.get_node_id(&key.clone().into())
+                    && let Some(content_node_id) = raw_doc
+                        .node(footnote_node_id)
+                        .as_map()
+                        .and_then(|m| m.get_node_id(&"content".into()))
+                {
+                    ctx.check_content(
+                        &footnote.content,
+                        &format!("in footnote '{key}'"),
+                        content_node_id,
+                    );
+                }
+            }
+        }
+    }
+
+    ctx.result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;