rumdl 0.0.166__tar.gz → 0.0.167__tar.gz

{rumdl-0.0.166 → rumdl-0.0.167}/.config/nextest.toml

@@ -22,21 +22,24 @@ status-level = "pass"
 
 [profile.ci]
 
-# Skip performance tests in CI (they're flaky due to resource variability)
+# Skip performance and memory tests in CI (they're flaky due to resource variability)
 # Exclude specific integration test binaries and performance-related test functions
-default-filter = 'not (package(rumdl) and binary(deeply_nested_lists_performance_test)) and not (package(rumdl) and binary(performance_validation_tests)) and not (package(rumdl) and binary(perf_check)) and not test(/performance|benchmark/)'
+default-filter = 'not (package(rumdl) and binary(deeply_nested_lists_performance_test)) and not (package(rumdl) and binary(performance_validation_tests)) and not (package(rumdl) and binary(perf_check)) and not test(/performance|benchmark|memory/)'
 
 # More conservative in CI
 test-threads = "num-cpus"
 
-# Always show all output in CI
+# Show failures immediately, but minimize successful test output for speed
 failure-output = "immediate"
-success-output = "immediate"
-status-level = "all"
+success-output = "final"
+status-level = "pass"
 
 # No retries in CI to catch flaky tests
 retries = 0
 
+# Fail fast on first failure to save CI time
+fail-fast = true
+
 # Quick profile for development
 [profile.quick]
 
@@ -88,8 +91,8 @@ fail-fast = true
 # Performance testing profile - for scheduled/manual runs
 [profile.performance]
 
-# Only run performance and benchmark tests
-default-filter = 'test(performance) or test(benchmark) or test(deeply_nested)'
+# Only run performance, benchmark, and memory tests
+default-filter = 'test(performance) or test(benchmark) or test(deeply_nested) or test(memory)'
 
 # Run tests serially to reduce noise
 test-threads = 1

{rumdl-0.0.166 → rumdl-0.0.167}/.pre-commit-config.yaml

@@ -8,6 +8,8 @@
 #   pre-commit run --hook-stage push --all-files       # Run push hooks
 #   pre-commit run --hook-stage commit-msg --commit-msg-filename .git/COMMIT_EDITMSG
 
+fail_fast: true
+
 repos:
   # Conventional Commits validation
   - repo: https://github.com/compilerla/conventional-pre-commit

{rumdl-0.0.166 → rumdl-0.0.167}/.rumdl.toml

@@ -8,11 +8,11 @@ include = [
 ]
 # Globally disable specific rules
 disable = ["MD033"]
-respect_gitignore = true
+respect-gitignore = true
 
 [MD013]
-line_length = 200
-code_blocks = true
+line-length = 200
+code-blocks = true
 tables = false
 headings = true
 reflow = true

{rumdl-0.0.166 → rumdl-0.0.167}/CHANGELOG.md

@@ -7,6 +7,83 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.167] - 2025-10-24
+
+### Added
+
+- **Configuration validation with fuzzy-match suggestions**
+  - Comprehensive unknown key detection for `.rumdl.toml` and `pyproject.toml`
+  - Intelligent "did you mean?" suggestions using Levenshtein distance algorithm
+  - File path context in validation warnings for easy debugging
+  - Catches typos in global options, rule names, and rule options
+  - Example: `line-lenght` → suggests `line-length`, `reflw` → suggests `reflow`
+  - Zero-dependency implementation with configurable similarity threshold
+  - Helps users catch configuration mistakes before they cause confusion
+
+- **MD053: Support for community comment-style references**
+  - Recognizes and ignores reference-style link syntax used as comments
+  - Supports widely-used patterns: `[//]: # (comment)`, `[comment]: #`, `[note]: #`, `[todo]: #`, `[fixme]: #`, `[hack]: #`
+  - Any reference with just `#` as URL is treated as a comment
+  - While not in CommonMark/GFM specs, used across 23+ markdown implementations
+  - Complements HTML comments with a less HTML-like syntax option
+  - Improves compatibility with existing markdown practices
+
+- **MD013: `line-length = 0` to disable all line length checks**
+  - Setting `line-length = 0` now completely disables MD013 rule
+  - Provides explicit way to turn off line length validation entirely
+  - More intuitive than previous workarounds
+  - Useful when line length management is handled by other tools or not desired
+
+- **MD051: mdbook template support**
+  - Added detection and slug generation for mdbook templates
+  - Recognizes `{{#template path/to/file.md}}` syntax
+  - Properly generates GitHub-compatible slugs for template-included headings
+  - Improves compatibility with mdbook documentation projects
+
+- **LSP: Manual "Reflow paragraph" code action for MD013 warnings**
+  - New code action available for MD013 line length warnings when auto-reflow is disabled
+  - Allows users to manually reflow specific paragraphs without enabling global reflow in config
+  - Appears as "Reflow paragraph" in Quick Fix menu (not marked as preferred, so won't trigger on save)
+  - Intelligently detects paragraph boundaries and reflows entire paragraph, not just the flagged line
+  - Respects line length limit from warning message or defaults to 80 characters
+  - Provides a way to try paragraph reflow before committing to enabling it globally
+  - Gives users fine-grained control over which paragraphs to reflow
+
+### Fixed
+
+- **LSP: Preserve trailing newline in reflow action**
+  - Manual reflow code action now correctly preserves trailing newlines
+  - Prevents unwanted file modifications from reflow operations
+  - Maintains document structure integrity
+
+- **LSP: Improve logging and resolve auto-fix issues**
+  - Enhanced LSP server logging for better debugging
+  - Resolved various auto-fix edge cases and reliability issues
+
+- **MD051: Correct GitHub slug generation for angle brackets**
+  - Fixed incorrect slug generation for headings containing angle brackets
+  - Now properly handles special characters in anchor generation
+  - Improves accuracy of link validation for complex headings
+
+### Changed
+
+- **MD033: Remove unhelpful message suffix**
+  - Simplified warning messages for inline HTML detection
+  - Removed redundant information to reduce noise
+  - Cleaner, more focused error messages
+
+- **Code cleanup: Remove dead code**
+  - Removed unused `LinkImageStyle` enum from MD054
+  - General refactoring to improve maintainability
+  - Fixed clippy warnings
+
+### Documentation
+
+- **MD033: Document mdbook use case for semantic HTML**
+  - Added documentation about using semantic HTML in mdbook projects
+  - Clarifies when and why inline HTML might be intentionally used
+  - Helps users understand legitimate use cases for HTML in markdown
+
 ## [0.0.166] - 2025-10-22
 
 ### Added

{rumdl-0.0.166 → rumdl-0.0.167}/Cargo.lock

@@ -1983,7 +1983,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.166"
+version = "0.0.167"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.166 → rumdl-0.0.167}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.166"
+version = "0.0.167"
 edition = "2024"
 rust-version = "1.89.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"

{rumdl-0.0.166 → rumdl-0.0.167}/Makefile

@@ -95,8 +95,8 @@ test-pre-commit:
 	cargo nextest run --profile pre-commit
 
 test-push:
-	@echo "Running comprehensive test suite (~30s, excludes slow/performance tests)..."
-	cargo nextest run --profile dev
+	@echo "Running CI test suite (excludes performance tests)..."
+	cargo nextest run --profile ci
 
 test-ci:
 	cargo nextest run --profile ci

{rumdl-0.0.166 → rumdl-0.0.167}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.166
+Version: 0.0.167
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{rumdl-0.0.166 → rumdl-0.0.167}/docs/md013.md

@@ -62,7 +62,7 @@ MD013:
 
 ### Configuration options explained
 
-- `line_length`: The maximum number of characters allowed per line
+- `line_length`: The maximum number of characters allowed per line (set to `0` to disable all line length checks)
 - `code_blocks`: Whether to check line length in code blocks
 - `tables`: Whether to check line length in tables
 - `headings`: Whether to check line length in headings
@@ -195,6 +195,25 @@ This configuration is useful when:
 - You care about line length in code blocks and tables but not in regular text
 - You're using semantic line breaks where sentence length is determined by content, not arbitrary limits
 
+#### Disabling all line length checks
+
+If you want to completely disable all line length checking (for paragraphs, headings, code blocks, and tables), set `line-length` to `0`:
+
+```yaml
+MD013:
+  line-length: 0  # Disable all line length checks
+  reflow: true
+  reflow-mode: "sentence-per-line"
+```
+
+When `line-length` is set to `0`, no line length warnings will be reported for any content type. This is particularly useful for:
+
+- Projects using semantic line breaks where lines break at logical boundaries regardless of length
+- Sentence-per-line workflows where line length is not a concern
+- Documentation where long lines (e.g., URLs, technical terms) are unavoidable and acceptable
+
+**Note**: With `line-length: 0`, reflow still works (using a very large effective line length), so you can still use `sentence-per-line` mode for automatic formatting without any line length warnings.
+
 ### Example with automatic reflow
 
 ```yaml

{rumdl-0.0.166 → rumdl-0.0.167}/docs/md033.md

@@ -89,6 +89,24 @@ MD033:
 
 This would allow line breaks, horizontal rules, and collapsible sections while blocking other HTML.
 
+### mdbook projects with semantic HTML
+
+mdbook documentation often uses HTML with CSS classes to add semantic meaning that pure Markdown cannot express (e.g., marking text as filenames, captions, or warnings). For mdbook projects, you can
+allow semantic containers:
+
+```toml
+[tool.rumdl.MD033]
+allowed-elements = ["div", "span"]
+```
+
+This permits semantic HTML like:
+
+- `<span class="filename">src/main.rs</span>` - Filename styling
+- `<div class="warning">Important note</div>` - Warning boxes
+- `<span class="caption">Figure 1: Architecture</span>` - Figure captions
+
+While still catching potentially problematic HTML like `<em>`, `<strong>`, or `<script>` tags that have Markdown equivalents or security concerns.
+
 ## Automatic fixes
 
 This rule can automatically remove HTML tags when no allowed elements are configured. When specific tags are allowed via `allowed_elements`, those tags will be preserved while others are removed.

{rumdl-0.0.166 → rumdl-0.0.167}/docs/md053.md

@@ -64,6 +64,65 @@ MD053:
 
 This keeps reference definitions with names like "todo", "draft", or "template" even if they're not currently used.
 
+## Comment-Style References
+
+rumdl automatically recognizes and ignores common community patterns for adding comments using reference-style syntax. These patterns are **not part of any official Markdown specification**
+(CommonMark, GFM), but are widely used across 23+ Markdown implementations.
+
+### Recognized Comment Patterns
+
+The following patterns are automatically ignored and won't be flagged as unused:
+
+```markdown
+[//]: # (This is a comment - most popular pattern)
+[comment]: # (This is a semantic comment)
+[note]: # (This is a note for documentation)
+[todo]: # (Add more examples here)
+[fixme]: # (This needs to be fixed)
+[hack]: # (Temporary workaround)
+```
+
+Any reference definition with just `#` as the URL is also treated as a comment:
+
+```markdown
+[anything]: # (This will be treated as a comment)
+[ref]: # "Also a comment"
+```
+
+### Why These Work
+
+These patterns exploit valid Markdown link reference syntax:
+
+- The label (e.g., `[//]`) is technically valid
+- The `#` is a valid URL (just a fragment/anchor)
+- Since the reference is never used, it doesn't render
+
+### When to Use
+
+**Use HTML comments for standard commenting:**
+
+```markdown
+<!-- This is the recommended way to add comments -->
+```
+
+**Use reference-style comments when:**
+
+- Your documentation tool strips HTML comments
+- You prefer a less HTML-like syntax
+- You're following project conventions that use this pattern
+- You need comments that won't appear in page source
+
+### Real vs. Comment References
+
+rumdl distinguishes between comment patterns and real references:
+
+```markdown
+[//]: # (This is ignored - it's a comment)
+[real-link]: https://example.com  <!-- This WILL be flagged if unused -->
+```
+
+Only the real reference definition will trigger MD053 if it's not used in the document.
+
 ## Automatic fixes
 
 This rule can automatically fix issues by:

{rumdl-0.0.166 → rumdl-0.0.167}/src/config.rs

@@ -88,7 +88,7 @@ pub fn normalize_key(key: &str) -> String {
 }
 
 /// Represents a rule-specific configuration
-#[derive(Debug, Serialize, Deserialize, Default, PartialEq, schemars::JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, schemars::JsonSchema)]
 pub struct RuleConfig {
     /// Configuration values for the rule
     #[serde(flatten)]
@@ -110,7 +110,7 @@ fn arbitrary_value_schema(_gen: &mut schemars::r#gen::SchemaGenerator) -> schema
 }
 
 /// Represents the complete configuration loaded from rumdl.toml
-#[derive(Debug, Serialize, Deserialize, Default, PartialEq, schemars::JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, schemars::JsonSchema)]
 #[schemars(
     description = "rumdl configuration for linting Markdown files. Rules can be configured individually using [MD###] sections with rule-specific options."
 )]
@@ -205,7 +205,7 @@ impl Config {
 }
 
 /// Global configuration options
-#[derive(Debug, Serialize, Deserialize, PartialEq, schemars::JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, schemars::JsonSchema)]
 #[serde(default)]
 pub struct GlobalConfig {
     /// Enabled rules
@@ -340,7 +340,7 @@ exclude = [
 ]
 
 # Respect .gitignore files when scanning directories (default: true)
-respect_gitignore = true
+respect-gitignore = true
 
 # Markdown flavor/dialect (uncomment to enable)
 # Options: mkdocs, gfm, commonmark
@@ -358,8 +358,8 @@ respect_gitignore = true
 # indent = 4  # Unordered list indentation
 
 # [MD013]
-# line_length = 100  # Line length
-# code_blocks = false  # Exclude code blocks from line length check
+# line-length = 100  # Line length
+# code-blocks = false  # Exclude code blocks from line length check
 # tables = false  # Exclude tables from line length check
 # headings = true  # Include headings in line length check
 
@@ -452,8 +452,8 @@ respect-gitignore = true
 # indent = 4  # Unordered list indentation
 
 # [tool.rumdl.MD013]
-# line_length = 100  # Line length
-# code_blocks = false  # Exclude code blocks from line length check
+# line-length = 100  # Line length
+# code-blocks = false  # Exclude code blocks from line length check
 # tables = false  # Exclude tables from line length check
 # headings = true  # Include headings in line length check
 
@@ -1468,7 +1468,8 @@ pub struct SourcedConfigFragment {
     pub global: SourcedGlobalConfig,
     pub per_file_ignores: SourcedValue<HashMap<String, Vec<String>>>,
     pub rules: BTreeMap<String, SourcedRuleConfig>,
-    // Note: Does not include loaded_files or unknown_keys, as those are tracked globally.
+    pub unknown_keys: Vec<(String, String, Option<String>)>, // (section, key, file_path)
+                                                             // Note: loaded_files is tracked globally in SourcedConfig.
 }
 
 impl Default for SourcedConfigFragment {
@@ -1477,6 +1478,7 @@ impl Default for SourcedConfigFragment {
             global: SourcedGlobalConfig::default(),
             per_file_ignores: SourcedValue::new(HashMap::new(), ConfigSource::Default),
             rules: BTreeMap::new(),
+            unknown_keys: Vec::new(),
         }
     }
 }
@@ -1487,7 +1489,7 @@ pub struct SourcedConfig {
     pub per_file_ignores: SourcedValue<HashMap<String, Vec<String>>>,
     pub rules: BTreeMap<String, SourcedRuleConfig>,
     pub loaded_files: Vec<String>,
-    pub unknown_keys: Vec<(String, String)>, // (section, key)
+    pub unknown_keys: Vec<(String, String, Option<String>)>, // (section, key, file_path)
 }
 
 impl Default for SourcedConfig {
@@ -1628,6 +1630,14 @@ impl SourcedConfig {
                 );
             }
         }
+
+        // Merge unknown_keys from fragment
+        for (section, key, file_path) in fragment.unknown_keys {
+            // Deduplicate: only add if not already present
+            if !self.unknown_keys.iter().any(|(s, k, _)| s == &section && k == &key) {
+                self.unknown_keys.push((section, key, file_path));
+            }
+        }
     }
 
     /// Load and merge configurations from files and CLI overrides.
@@ -1956,7 +1966,7 @@ impl SourcedConfig {
             // No rule-specific CLI overrides implemented yet
         }
 
-        // TODO: Handle unknown keys collected during parsing/merging
+        // Unknown keys are now collected during parsing and validated via validate_config_sourced()
 
         Ok(sourced_config)
     }
@@ -2145,8 +2155,14 @@ pub fn validate_config_sourced(sourced: &SourcedConfig, registry: &RuleRegistry)
         if let Some(valid_keys) = registry.config_keys_for(rule) {
             for key in rule_cfg.values.keys() {
                 if !valid_keys.contains(key) {
+                    let valid_keys_vec: Vec<String> = valid_keys.iter().cloned().collect();
+                    let message = if let Some(suggestion) = suggest_similar_key(key, &valid_keys_vec) {
+                        format!("Unknown option for rule {rule}: {key} (did you mean: {suggestion}?)")
+                    } else {
+                        format!("Unknown option for rule {rule}: {key}")
+                    };
                     warnings.push(ConfigValidationWarning {
-                        message: format!("Unknown option for rule {rule}: {key}"),
+                        message,
                         rule: Some(rule.clone()),
                         key: Some(key.clone()),
                     });
@@ -2173,13 +2189,60 @@ pub fn validate_config_sourced(sourced: &SourcedConfig, registry: &RuleRegistry)
         }
     }
     // 3. Unknown global options (from unknown_keys)
-    for (section, key) in &sourced.unknown_keys {
-        if section.contains("[global]") {
+    let known_global_keys = vec![
+        "enable".to_string(),
+        "disable".to_string(),
+        "include".to_string(),
+        "exclude".to_string(),
+        "respect-gitignore".to_string(),
+        "line-length".to_string(),
+        "fixable".to_string(),
+        "unfixable".to_string(),
+        "flavor".to_string(),
+        "force-exclude".to_string(),
+        "output-format".to_string(),
+    ];
+
+    for (section, key, file_path) in &sourced.unknown_keys {
+        if section.contains("[global]") || section.contains("[tool.rumdl]") {
+            let message = if let Some(suggestion) = suggest_similar_key(key, &known_global_keys) {
+                if let Some(path) = file_path {
+                    format!("Unknown global option in {path}: {key} (did you mean: {suggestion}?)")
+                } else {
+                    format!("Unknown global option: {key} (did you mean: {suggestion}?)")
+                }
+            } else if let Some(path) = file_path {
+                format!("Unknown global option in {path}: {key}")
+            } else {
+                format!("Unknown global option: {key}")
+            };
             warnings.push(ConfigValidationWarning {
-                message: format!("Unknown global option: {key}"),
+                message,
                 rule: None,
                 key: Some(key.clone()),
             });
+        } else if !key.is_empty() {
+            // This is an unknown rule section (key is empty means it's a section header)
+            // No suggestions for rule names - just warn
+            continue;
+        } else {
+            // Unknown rule section
+            let message = if let Some(path) = file_path {
+                format!(
+                    "Unknown rule in {path}: {}",
+                    section.trim_matches(|c| c == '[' || c == ']')
+                )
+            } else {
+                format!(
+                    "Unknown rule in config: {}",
+                    section.trim_matches(|c| c == '[' || c == ']')
+                )
+            };
+            warnings.push(ConfigValidationWarning {
+                message,
+                rule: None,
+                key: None,
+            });
         }
     }
     warnings
@@ -2197,6 +2260,63 @@ fn toml_type_name(val: &toml::Value) -> &'static str {
     }
 }
 
+/// Calculate Levenshtein distance between two strings (simple implementation)
+fn levenshtein_distance(s1: &str, s2: &str) -> usize {
+    let len1 = s1.len();
+    let len2 = s2.len();
+
+    if len1 == 0 {
+        return len2;
+    }
+    if len2 == 0 {
+        return len1;
+    }
+
+    let s1_chars: Vec<char> = s1.chars().collect();
+    let s2_chars: Vec<char> = s2.chars().collect();
+
+    let mut prev_row: Vec<usize> = (0..=len2).collect();
+    let mut curr_row = vec![0; len2 + 1];
+
+    for i in 1..=len1 {
+        curr_row[0] = i;
+        for j in 1..=len2 {
+            let cost = if s1_chars[i - 1] == s2_chars[j - 1] { 0 } else { 1 };
+            curr_row[j] = (prev_row[j] + 1)          // deletion
+                .min(curr_row[j - 1] + 1)            // insertion
+                .min(prev_row[j - 1] + cost); // substitution
+        }
+        std::mem::swap(&mut prev_row, &mut curr_row);
+    }
+
+    prev_row[len2]
+}
+
+/// Suggest a similar key from a list of valid keys using fuzzy matching
+fn suggest_similar_key(unknown: &str, valid_keys: &[String]) -> Option<String> {
+    let unknown_lower = unknown.to_lowercase();
+    let max_distance = 2.max(unknown.len() / 3); // Allow up to 2 edits or 30% of string length
+
+    let mut best_match: Option<(String, usize)> = None;
+
+    for valid in valid_keys {
+        let valid_lower = valid.to_lowercase();
+        let distance = levenshtein_distance(&unknown_lower, &valid_lower);
+
+        if distance <= max_distance {
+            if let Some((_, best_dist)) = &best_match {
+                if distance < *best_dist {
+                    best_match = Some((valid.clone(), distance));
+                }
+            } else {
+                best_match = Some((valid.clone(), distance));
+            }
+        }
+    }
+
+    best_match.map(|(key, _)| key)
+}
+
 fn toml_value_type_matches(expected: &toml::Value, actual: &toml::Value) -> bool {
     use toml::Value::*;
     match (expected, actual) {
@@ -2438,8 +2558,10 @@ fn parse_pyproject_toml(content: &str, path: &str) -> Result<Option<SourcedConfi
                 }
             } else {
                 // Key is not a global/special key, doesn't start with 'md', or isn't a table.
-                // TODO: Track unknown keys/sections if necessary for validation later.
-                // eprintln!("[DEBUG parse_pyproject] Skipping key '{}' as it's not a recognized rule table.", key);
+                // Track unknown keys under [tool.rumdl] for validation
+                fragment
+                    .unknown_keys
+                    .push(("[tool.rumdl]".to_string(), key.to_string(), Some(path.to_string())));
             }
         }
     }
@@ -2464,6 +2586,13 @@ fn parse_pyproject_toml(content: &str, path: &str) -> Result<Option<SourcedConfi
                             .or_insert_with(|| SourcedValue::new(toml_val.clone(), source));
                         sv.push_override(toml_val, source, file.clone(), None);
                     }
+                } else if rule_name.to_ascii_uppercase().starts_with("MD") {
+                    // Track unknown rule sections like [tool.rumdl.MD999]
+                    fragment.unknown_keys.push((
+                        format!("[tool.rumdl.{rule_name}]"),
+                        String::new(),
+                        Some(path.to_string()),
+                    ));
                 }
             }
         }
@@ -2489,6 +2618,13 @@ fn parse_pyproject_toml(content: &str, path: &str) -> Result<Option<SourcedConfi
                             .or_insert_with(|| SourcedValue::new(toml_val.clone(), source));
                         sv.push_override(toml_val, source, file.clone(), None);
                     }
+                } else if rule_name.to_ascii_uppercase().starts_with("MD") {
+                    // Track unknown rule sections like [tool.rumdl.MD999]
+                    fragment.unknown_keys.push((
+                        format!("[tool.rumdl.{rule_name}]"),
+                        String::new(),
+                        Some(path.to_string()),
+                    ));
                 }
             }
         }
@@ -2715,8 +2851,10 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
                     }
                 }
                 _ => {
-                    // Add to unknown_keys for potential validation later
-                    // fragment.unknown_keys.push(("[global]".to_string(), key.to_string()));
+                    // Track unknown global keys for validation
+                    fragment
+                        .unknown_keys
+                        .push(("[global]".to_string(), key.to_string(), Some(path.to_string())));
                     log::warn!("[WARN] Unknown key in [global] section of {path}: {key}");
                 }
             }
@@ -2751,9 +2889,23 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
     // Rule-specific: all other top-level tables
     for (key, item) in doc.iter() {
         let norm_rule_name = key.to_ascii_uppercase();
+
+        // Skip known special sections
+        if key == "global" || key == "per-file-ignores" {
+            continue;
+        }
+
+        // Track unknown rule sections (like [MD999])
         if !known_rule_names.contains(&norm_rule_name) {
+            // Only track if it looks like a rule section (starts with MD or is uppercase)
+            if norm_rule_name.starts_with("MD") || key.chars().all(|c| c.is_uppercase() || c.is_numeric()) {
+                fragment
+                    .unknown_keys
+                    .push((format!("[{key}]"), String::new(), Some(path.to_string())));
+            }
             continue;
         }
+
         if let Some(tbl) = item.as_table() {
             let rule_entry = fragment.rules.entry(norm_rule_name.clone()).or_default();
             for (rk, rv_item) in tbl.iter() {

{rumdl-0.0.166 → rumdl-0.0.167}/src/lsp/mod.rs

@@ -10,7 +10,7 @@ pub mod server;
 pub mod types;
 
 pub use server::RumdlLanguageServer;
-pub use types::{RumdlLspConfig, warning_to_code_action, warning_to_diagnostic};
+pub use types::{RumdlLspConfig, warning_to_code_actions, warning_to_diagnostic};
 
 use anyhow::Result;
 use tokio::net::TcpListener;
@@ -64,7 +64,7 @@ mod tests {
                 &crate::rule::LintWarning,
                 &tower_lsp::lsp_types::Url,
                 &str,
-            ) -> Option<tower_lsp::lsp_types::CodeAction> = warning_to_code_action;
+            ) -> Vec<tower_lsp::lsp_types::CodeAction> = warning_to_code_actions;
         }
     }