rumdl 0.0.104__tar.gz → 0.0.105__tar.gz

{rumdl-0.0.104 → rumdl-0.0.105}/.pre-commit-config.yaml

@@ -40,7 +40,7 @@ repos:
     rev: v4.6.0
     hooks:
       - id: trailing-whitespace
-        exclude: \.md$
+        exclude: \.md$|tests/inline_config_test\.rs$
       - id: end-of-file-fixer
         exclude: \.md$
       - id: check-yaml

{rumdl-0.0.104 → rumdl-0.0.105}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.105] - 2025-08-05
+
 ## [0.0.104] - 2025-08-02
 
 ### Added
@@ -259,7 +261,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial implementation of remaining rules for markdownlint parity
 
-[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.104...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.105...HEAD
+[0.0.105]: https://github.com/rvben/rumdl/compare/v0.0.104...v0.0.105
 [0.0.104]: https://github.com/rvben/rumdl/compare/v0.0.103...v0.0.104
 [0.0.102]: https://github.com/rvben/rumdl/compare/v0.0.101...v0.0.102
 [0.0.101]: https://github.com/rvben/rumdl/compare/v0.0.100...v0.0.101

{rumdl-0.0.104 → rumdl-0.0.105}/Cargo.lock

@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.104"
+version = "0.0.105"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1680,9 +1680,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.5"
+version = "1.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410"
+checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
 dependencies = [
  "libc",
 ]
@@ -1856,9 +1856,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.15"
+version = "0.7.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66a539a9ad6d5d281510d5bd368c973d636c02dbf8a67300bfb6b950696ad7df"
+checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5"
 dependencies = [
  "bytes",
  "futures-core",
@@ -2527,9 +2527,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428"
+checksum = "bdbb9122ea75b11bf96e7492afb723e8a7fbe12c67417aa95e7e3d18144d37cd"
 dependencies = [
  "yoke",
  "zerofrom",

{rumdl-0.0.104 → rumdl-0.0.105}/Cargo.toml

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

{rumdl-0.0.104 → rumdl-0.0.105}/PKG-INFO

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

{rumdl-0.0.104 → rumdl-0.0.105}/docs/md013.md

@@ -55,6 +55,7 @@ MD013:
   code_block_line_length: 150   # Different limit for code blocks (default: uses line_length)
   stern: false                  # Stricter checking without exceptions (default: false)
   strict: false                 # Disables exceptions for URLs, etc. (default: false)
+  enable_reflow: false          # Enable automatic text reflow/wrapping (default: false)
 ```
 
 ### Configuration options explained
@@ -67,6 +68,7 @@ MD013:
 - `code_block_line_length`: Optional separate limit for code blocks
 - `stern`: When true, applies stricter checking without common exceptions
 - `strict`: When true, disables exceptions for URLs and other special content
+- `enable_reflow`: When true, enables automatic text reflow to wrap long lines intelligently
 
 ### Example with different limits
 
@@ -98,7 +100,25 @@ def very_long_function_name_that_demonstrates_the_code_block_line_length_configu
 
 ## Automatic fixes
 
-This rule doesn't automatically fix long lines because breaking them requires understanding the content's meaning. You'll need to manually wrap lines at appropriate points.
+When `enable_reflow` is set to `true`, this rule can automatically wrap long lines while preserving Markdown formatting:
+
+- Intelligently breaks lines at appropriate points
+- Preserves bold, italic, links, code spans, and other Markdown elements
+- Maintains proper list continuation indentation
+- Preserves hard line breaks (two trailing spaces)
+- Does not wrap code blocks, tables, headings, or reference definitions
+
+### Example with automatic reflow
+
+```yaml
+MD013:
+  line_length: 80
+  enable_reflow: true
+```
+
+With this configuration, long lines will be automatically wrapped to fit within 80 characters while maintaining proper Markdown formatting.
+
+**Note**: When `enable_reflow` is `false` (default), automatic fixes are not available and you'll need to manually wrap long lines.
 
 ## Learn more
 

{rumdl-0.0.104 → rumdl-0.0.105}/docs/md033.md

@@ -58,7 +58,20 @@ This is a paragraph with <strong>bold</strong> and <em>italic</em> text.
 
 ### 🔧 Fixed
 
-This rule cannot automatically fix HTML tags because it can't always determine the equivalent Markdown syntax. You need to manually replace HTML with Markdown.
+```markdown
+# Heading
+
+This is a paragraph with **bold** and *italic* text.
+
+> This is a quote
+
+- List item 1
+- List item 2
+
+[Link text](https://example.com)
+
+![Image description](image.png)
+```
 
 ## Configuration
 
@@ -78,7 +91,9 @@ This would allow line breaks, horizontal rules, and collapsible sections while b
 
 ## Automatic fixes
 
-This rule does not provide automatic fixes. HTML must be manually converted to Markdown syntax.
+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.
+
+**Note**: The automatic fix removes HTML tags but does not convert them to Markdown equivalents. You may need to manually add appropriate Markdown formatting after the fix.
 
 ## What's allowed
 

{rumdl-0.0.104 → rumdl-0.0.105}/docs/md044.md

@@ -62,6 +62,7 @@ MD044:
     - "npm"                  # Yes, npm is lowercase!
   code_blocks: false         # Check inside code blocks (default: true)
   html_elements: true        # Check inside HTML elements (default: true)
+  html_comments: true        # Check inside HTML comments (default: true)
 ```
 
 ## Automatic fixes
@@ -76,6 +77,7 @@ When enabled, this rule will:
 - Only checks names you've configured
 - Won't check inside URLs or file paths
 - Respects `code_blocks` setting for technical documentation
+- Respects `html_comments` setting for HTML comment content
 - Some names are intentionally lowercase (like "npm")
 
 ## Learn more

{rumdl-0.0.104 → rumdl-0.0.105}/src/lint_context.rs

@@ -241,6 +241,8 @@ pub struct ListBlock {
     pub item_lines: Vec<usize>,
     /// Nesting level (0 for top-level lists)
     pub nesting_level: usize,
+    /// Maximum marker width seen in this block (e.g., 3 for "1. ", 4 for "10. ")
+    pub max_marker_width: usize,
 }
 
 use std::sync::{Arc, Mutex};
@@ -1072,7 +1074,8 @@ impl<'a> LintContext<'a> {
 
                 // Check for various blockquote issues
                 let has_no_space = spaces_after.is_empty() && !content.is_empty();
-                let has_multiple_spaces = spaces_after.len() > 1;
+                // Consider tabs as multiple spaces, or actual multiple spaces
+                let has_multiple_spaces = spaces_after.len() > 1 || spaces_after.contains('\t');
 
                 // Check if needs MD028 fix (empty blockquote without proper spacing)
                 let needs_md028_fix = content.trim().is_empty() && spaces_after.is_empty();
@@ -1293,6 +1296,7 @@ impl<'a> LintContext<'a> {
         let mut current_block: Option<ListBlock> = None;
         let mut last_list_item_line = 0;
         let mut current_indent_level = 0;
+        let mut last_marker_width = 0;
 
         for (line_idx, line_info) in lines.iter().enumerate() {
             let line_num = line_idx + 1;
@@ -1302,7 +1306,16 @@ impl<'a> LintContext<'a> {
                 if let Some(ref mut block) = current_block {
                     // For code blocks to continue a list, they need to be indented
                     // at least 2 spaces beyond the list marker
-                    if line_info.indent >= current_indent_level + 2 {
+                    // Calculate minimum indentation for list continuation
+                    // For ordered lists, use the last marker width (e.g., 3 for "1. ", 4 for "10. ")
+                    // For unordered lists like "- ", content starts at column 2, so continuations need at least 2 spaces
+                    let min_continuation_indent = if block.is_ordered {
+                        current_indent_level + last_marker_width
+                    } else {
+                        current_indent_level + 2 // Unordered lists need at least 2 spaces (e.g., "- " = 2 chars)
+                    };
+
+                    if line_info.indent >= min_continuation_indent {
                         // Code blocks at list continuation level should continue the list
                         block.end_line = line_num;
                         continue;
@@ -1348,8 +1361,28 @@ impl<'a> LintContext<'a> {
                                 let check_info = &lines[check_idx];
                                 if !check_info.is_blank && !check_info.in_code_block && check_info.list_item.is_none() {
                                     // Found non-blank, non-list content
-                                    if check_info.indent < 2 {
-                                        // Not indented, so it's not list continuation
+                                    // Check if it's indented enough to be a continuation
+                                    // Get the marker width of the last list item
+                                    let last_item_marker_width =
+                                        if last_list_item_line > 0 && last_list_item_line <= lines.len() {
+                                            lines[last_list_item_line - 1]
+                                                .list_item
+                                                .as_ref()
+                                                .map(|li| {
+                                                    if li.is_ordered {
+                                                        li.marker.len() + 1 // Add 1 for the space after ordered list markers
+                                                    } else {
+                                                        li.marker.len()
+                                                    }
+                                                })
+                                                .unwrap_or(3) // fallback to 3 if no list item found
+                                        } else {
+                                            3 // fallback
+                                        };
+
+                                    let min_continuation = if block.is_ordered { last_item_marker_width } else { 2 };
+                                    if check_info.indent < min_continuation {
+                                        // Not indented enough, so it breaks the list
                                         found_non_list = true;
                                         break;
                                     }
@@ -1364,6 +1397,13 @@ impl<'a> LintContext<'a> {
                         block.end_line = line_num;
                         block.item_lines.push(line_num);
 
+                        // Update max marker width
+                        block.max_marker_width = block.max_marker_width.max(if list_item.is_ordered {
+                            list_item.marker.len() + 1
+                        } else {
+                            list_item.marker.len()
+                        });
+
                         // Update marker consistency for unordered lists
                         if !block.is_ordered
                             && block.marker.is_some()
@@ -1388,6 +1428,11 @@ impl<'a> LintContext<'a> {
                             blockquote_prefix: blockquote_prefix.clone(),
                             item_lines: vec![line_num],
                             nesting_level: nesting,
+                            max_marker_width: if list_item.is_ordered {
+                                list_item.marker.len() + 1
+                            } else {
+                                list_item.marker.len()
+                            },
                         };
                     }
                 } else {
@@ -1404,11 +1449,17 @@ impl<'a> LintContext<'a> {
                         blockquote_prefix,
                         item_lines: vec![line_num],
                         nesting_level: nesting,
+                        max_marker_width: list_item.marker.len(),
                     });
                 }
 
                 last_list_item_line = line_num;
                 current_indent_level = item_indent;
+                last_marker_width = if list_item.is_ordered {
+                    list_item.marker.len() + 1 // Add 1 for the space after ordered list markers
+                } else {
+                    list_item.marker.len()
+                };
             } else if let Some(ref mut block) = current_block {
                 // Not a list item - check if it continues the current block
 
@@ -1417,7 +1468,16 @@ impl<'a> LintContext<'a> {
                 // - Blank lines followed by indented content continue the list
                 // - Everything else ends the list
 
-                if line_info.indent >= current_indent_level + 2 {
+                // Calculate minimum indentation for list continuation
+                // For ordered lists, use the last marker width (e.g., 3 for "1. ", 4 for "10. ")
+                // For unordered lists like "- ", content starts at column 2, so continuations need at least 2 spaces
+                let min_continuation_indent = if block.is_ordered {
+                    current_indent_level + last_marker_width
+                } else {
+                    current_indent_level + 2 // Unordered lists need at least 2 spaces (e.g., "- " = 2 chars)
+                };
+
+                if line_info.indent >= min_continuation_indent {
                     // Indented line continues the list
                     block.end_line = line_num;
                 } else if line_info.is_blank {
@@ -1434,7 +1494,7 @@ impl<'a> LintContext<'a> {
                     if check_idx < lines.len() {
                         let next_line = &lines[check_idx];
                         // Check if followed by indented content (list continuation)
-                        if !next_line.in_code_block && next_line.indent >= current_indent_level + 2 {
+                        if !next_line.in_code_block && next_line.indent >= min_continuation_indent {
                             found_continuation = true;
                         }
                         // Check if followed by another list item at the same level
@@ -1461,7 +1521,7 @@ impl<'a> LintContext<'a> {
                                             // Code fences or properly indented content
                                             trimmed.starts_with("```")
                                                 || trimmed.starts_with("~~~")
-                                                || line_indent >= current_indent_level + 2
+                                                || line_indent >= min_continuation_indent
                                         } else {
                                             false
                                         }
@@ -1489,8 +1549,20 @@ impl<'a> LintContext<'a> {
                     }
                 } else {
                     // Check for lazy continuation - non-indented line immediately after a list item
-                    let is_lazy_continuation =
-                        last_list_item_line == line_num - 1 && line_info.heading.is_none() && !line_info.is_blank;
+                    // But only if the line has sufficient indentation for the list type
+                    let min_required_indent = if block.is_ordered {
+                        current_indent_level + last_marker_width
+                    } else {
+                        current_indent_level + 2
+                    };
+
+                    // For lazy continuation to apply, the line must either:
+                    // 1. Have no indentation (true lazy continuation)
+                    // 2. Have sufficient indentation for the list type
+                    let is_lazy_continuation = last_list_item_line == line_num - 1
+                        && line_info.heading.is_none()
+                        && !line_info.is_blank
+                        && (line_info.indent == 0 || line_info.indent >= min_required_indent);
 
                     if is_lazy_continuation {
                         // Additional check: if the line starts with uppercase and looks like a new sentence,
@@ -1964,6 +2036,9 @@ impl<'a> ListBlockMerger<'a> {
         current.end_line = next.end_line;
         current.item_lines.extend_from_slice(&next.item_lines);
 
+        // Update max marker width
+        current.max_marker_width = current.max_marker_width.max(next.max_marker_width);
+
         // Handle marker consistency for unordered lists
         if !current.is_ordered && self.markers_differ(&current, next) {
             current.marker = None; // Mixed markers
@@ -2004,8 +2079,15 @@ fn has_meaningful_content_between(current: &ListBlock, next: &ListBlock, lines:
             let line_indent = line_info.content.len() - line_info.content.trim_start().len();
 
             // If the line is indented enough to be list continuation content, it's meaningful
-            // List content should be indented at least 2 spaces beyond the marker
-            if line_indent >= current.nesting_level + 2 {
+            // For ordered lists, use actual marker width; for unordered, 2 spaces
+            let min_indent = if current.is_ordered {
+                current.nesting_level + current.max_marker_width
+            } else {
+                current.nesting_level + 2
+            };
+
+            // Check if the line has sufficient indentation to be a continuation
+            if line_indent >= min_indent {
                 return true;
             }
 

{rumdl-0.0.104 → rumdl-0.0.105}/src/main.rs

@@ -219,9 +219,12 @@ enum Commands {
     },
     /// Install the rumdl VS Code extension
     Vscode {
-        /// Force reinstall even if already installed
+        /// Force reinstall the current version even if already installed
         #[arg(long)]
         force: bool,
+        /// Update to the latest version (only if newer version available)
+        #[arg(long)]
+        update: bool,
         /// Show installation status without installing
         #[arg(long)]
         status: bool,
@@ -1782,9 +1785,9 @@ build-backend = \"setuptools.build_meta\"
                     }
                 }
             }
-            Some(Commands::Vscode { force, status }) => {
+            Some(Commands::Vscode { force, update, status }) => {
                 // Handle VS Code extension installation
-                match rumdl::vscode::handle_vscode_command(*force, *status) {
+                match rumdl::vscode::handle_vscode_command(*force, *update, *status) {
                     Ok(_) => {}
                     Err(e) => {
                         eprintln!("{}: {}", "Error".red().bold(), e);

{rumdl-0.0.104 → rumdl-0.0.105}/src/rules/md027_multiple_spaces_blockquote.rs

@@ -55,37 +55,56 @@ impl Rule for MD027MultipleSpacesBlockquote {
             if let Some(blockquote) = &line_info.blockquote {
                 // Part 1: Check for multiple spaces after the blockquote marker
                 if blockquote.has_multiple_spaces_after_marker {
-                    // Calculate the position of the extra spaces
-                    let extra_spaces_start = blockquote.marker_column + blockquote.nesting_level + 1; // Position after all '>' markers + 1 for the first space
-                    let spaces_in_prefix = blockquote
-                        .prefix
-                        .chars()
-                        .skip(blockquote.indent.len() + blockquote.nesting_level)
-                        .take_while(|&c| c == ' ')
-                        .count();
-                    let extra_spaces_len = spaces_in_prefix - 1; // All spaces except the first one
-
-                    let (start_line, start_col, end_line, end_col) =
-                        calculate_match_range(line_num, &line_info.content, extra_spaces_start, extra_spaces_len);
+                    // Find where the extra spaces start in the line
+                    // We need to find the position after the markers and first space/tab
+                    let mut byte_pos = 0;
+                    let mut found_markers = 0;
+                    let mut found_first_space = false;
+
+                    for (i, ch) in line_info.content.char_indices() {
+                        if found_markers < blockquote.nesting_level {
+                            if ch == '>' {
+                                found_markers += 1;
+                            }
+                        } else if !found_first_space && (ch == ' ' || ch == '\t') {
+                            // This is the first space/tab after markers
+                            found_first_space = true;
+                        } else if found_first_space && (ch == ' ' || ch == '\t') {
+                            // This is where extra spaces start
+                            byte_pos = i;
+                            break;
+                        }
+                    }
 
-                    warnings.push(LintWarning {
-                        rule_name: Some(self.name()),
-                        line: start_line,
-                        column: start_col,
-                        end_line,
-                        end_column: end_col,
-                        message: "Multiple spaces after quote marker (>)".to_string(),
-                        severity: Severity::Warning,
-                        fix: Some(Fix {
-                            range: {
-                                let line_index = LineIndex::new(ctx.content.to_string());
-                                let start_byte = line_index.line_col_to_byte_range(line_num, start_col).start;
-                                let end_byte = line_index.line_col_to_byte_range(line_num, end_col).start;
-                                start_byte..end_byte
-                            },
-                            replacement: "".to_string(), // Remove the extra spaces
-                        }),
-                    });
+                    // Count how many extra spaces/tabs there are
+                    let extra_spaces_bytes = line_info.content[byte_pos..]
+                        .chars()
+                        .take_while(|&c| c == ' ' || c == '\t')
+                        .fold(0, |acc, ch| acc + ch.len_utf8());
+
+                    if extra_spaces_bytes > 0 {
+                        let (start_line, start_col, end_line, end_col) =
+                            calculate_match_range(line_num, &line_info.content, byte_pos, extra_spaces_bytes);
+
+                        warnings.push(LintWarning {
+                            rule_name: Some(self.name()),
+                            line: start_line,
+                            column: start_col,
+                            end_line,
+                            end_column: end_col,
+                            message: "Multiple spaces after quote marker (>)".to_string(),
+                            severity: Severity::Warning,
+                            fix: Some(Fix {
+                                range: {
+                                    let line_index = LineIndex::new(ctx.content.to_string());
+                                    let start_byte = line_index.line_col_to_byte_range(line_num, start_col).start;
+                                    let end_byte = line_index.line_col_to_byte_range(line_num, end_col).start;
+                                    start_byte..end_byte
+                                },
+                                replacement: "".to_string(), // Remove the extra spaces
+                            }),
+                        });
+                    }
                 }
             } else {
                 // Part 2: Check for malformed blockquote attempts on non-blockquote lines
@@ -515,4 +534,61 @@ mod tests {
         let fixed = rule.fix(&ctx).unwrap();
         assert_eq!(fixed, "  > Indented with multiple spaces");
     }
+
+    #[test]
+    fn test_tabs_after_marker() {
+        let rule = MD027MultipleSpacesBlockquote;
+        // Tab after marker - should be flagged as multiple spaces
+        let content = ">\tTab after marker";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1, "Tab after marker should be flagged");
+        assert_eq!(result[0].message, "Multiple spaces after quote marker (>)");
+
+        // Tab and space after marker
+        let content2 = ">\t Space then tab";
+        let ctx2 = LintContext::new(content2);
+        let result2 = rule.check(&ctx2).unwrap();
+        assert_eq!(result2.len(), 1, "Tab and space should be flagged");
+
+        // Two tabs after marker
+        let content3 = ">\t\tTwo tabs";
+        let ctx3 = LintContext::new(content3);
+        let result3 = rule.check(&ctx3).unwrap();
+        assert_eq!(result3.len(), 1, "Two tabs should be flagged");
+    }
+
+    #[test]
+    fn test_mixed_spaces_and_tabs() {
+        let rule = MD027MultipleSpacesBlockquote;
+        // Space then tab
+        let content = "> \tSpace then tab";
+        let ctx = LintContext::new(content);
+        let result = rule.check(&ctx).unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].column, 3); // Points to the tab
+
+        // Tab then space
+        let content2 = ">\t Tab then space";
+        let ctx2 = LintContext::new(content2);
+        let result2 = rule.check(&ctx2).unwrap();
+        assert_eq!(result2.len(), 1);
+        assert_eq!(result2[0].column, 3); // Points to the space after tab
+    }
+
+    #[test]
+    fn test_fix_tabs() {
+        let rule = MD027MultipleSpacesBlockquote;
+        // Fix should remove extra tabs
+        let content = ">\t\tTwo tabs";
+        let ctx = LintContext::new(content);
+        let fixed = rule.fix(&ctx).unwrap();
+        assert_eq!(fixed, "> Two tabs");
+
+        // Fix mixed spaces and tabs
+        let content2 = "> \t Mixed";
+        let ctx2 = LintContext::new(content2);
+        let fixed2 = rule.fix(&ctx2).unwrap();
+        assert_eq!(fixed2, "> Mixed");
+    }
 }

{rumdl-0.0.104 → rumdl-0.0.105}/src/utils/range_utils.rs

@@ -267,9 +267,24 @@ pub fn calculate_match_range(
     match_start: usize,
     match_len: usize,
 ) -> (usize, usize, usize, usize) {
+    // Bounds check to prevent panic
+    let line_len = line_content.len();
+    if match_start > line_len {
+        // If match_start is beyond line bounds, return a safe range at end of line
+        let char_count = line_content.chars().count();
+        return (line, char_count + 1, line, char_count + 1);
+    }
+
+    let safe_match_end = (match_start + match_len).min(line_len);
+    let safe_match_len = safe_match_end.saturating_sub(match_start);
+
     // Convert byte positions to character positions
     let char_start = line_content[..match_start].chars().count() + 1; // 1-indexed
-    let char_len = line_content[match_start..match_start + match_len].chars().count();
+    let char_len = if safe_match_len > 0 {
+        line_content[match_start..safe_match_end].chars().count()
+    } else {
+        0
+    };
     (line, char_start, line, char_start + char_len)
 }
 
@@ -444,4 +459,39 @@ mod tests {
         let range = line_index.line_text_range(1, 1, 100); // Should clamp to line end
         assert_eq!(range, 0..11); // "Hello world"
     }
+
+    #[test]
+    fn test_calculate_match_range_bounds_checking() {
+        // Test case 1: match_start beyond line bounds
+        let line_content = "] not a link [";
+        let (line, start_col, end_line, end_col) = calculate_match_range(121, line_content, 57, 10);
+        assert_eq!(line, 121);
+        assert_eq!(start_col, 15); // line length + 1
+        assert_eq!(end_line, 121);
+        assert_eq!(end_col, 15); // same as start when out of bounds
+
+        // Test case 2: match extends beyond line end
+        let line_content = "short";
+        let (line, start_col, end_line, end_col) = calculate_match_range(1, line_content, 2, 10);
+        assert_eq!(line, 1);
+        assert_eq!(start_col, 3); // position 2 + 1
+        assert_eq!(end_line, 1);
+        assert_eq!(end_col, 6); // clamped to line length + 1
+
+        // Test case 3: normal case within bounds
+        let line_content = "normal text here";
+        let (line, start_col, end_line, end_col) = calculate_match_range(5, line_content, 7, 4);
+        assert_eq!(line, 5);
+        assert_eq!(start_col, 8); // position 7 + 1
+        assert_eq!(end_line, 5);
+        assert_eq!(end_col, 12); // position 7 + 4 + 1
+
+        // Test case 4: zero length match
+        let line_content = "test line";
+        let (line, start_col, end_line, end_col) = calculate_match_range(10, line_content, 5, 0);
+        assert_eq!(line, 10);
+        assert_eq!(start_col, 6); // position 5 + 1
+        assert_eq!(end_line, 10);
+        assert_eq!(end_col, 6); // same as start for zero length
+    }
 }