feat(#59): implement wiki-link parser

- Created wiki-link-parser.ts utility for parsing [[links]] syntax - Supports multiple formats: [[Page Name]], [[Page|display]], [[slug]] - Returns parsed links with target, display text, and position info - Handles edge cases: nested brackets, escaped brackets, code blocks - Code block awareness: skips links in inline code, fenced blocks, and indented code - Comprehensive test suite with 43 passing tests (100% coverage) - Updated README.md with parser documentation Implements KNOW-007 (Issue #59) - Wiki-style linking foundation
2026-01-29 17:42:49 -06:00
parent 95833fb4ea
commit 1e5fcd19a4
10 changed files with 2068 additions and 0 deletions
--- a/apps/api/src/knowledge/utils/README.md
+++ b/apps/api/src/knowledge/utils/README.md
@@ -1,5 +1,139 @@
 # Knowledge Module Utilities

+## Wiki-Link Parser
+
+### Overview
+
+The `wiki-link-parser.ts` utility provides parsing of wiki-style `[[links]]` from markdown content. This is the foundation for the Knowledge Module's linking system.
+
+### Features
+
+- **Multiple Link Formats**: Supports title, slug, and display text variations
+- **Position Tracking**: Returns exact positions for link replacement or highlighting
+- **Code Block Awareness**: Skips links in code blocks (inline and fenced)
+- **Escape Support**: Respects escaped brackets `\[[not a link]]`
+- **Edge Case Handling**: Properly handles nested brackets, empty links, and malformed syntax
+
+### Usage
+
+```typescript
+import { parseWikiLinks } from './utils/wiki-link-parser';
+
+const content = 'See [[Main Page]] and [[Getting Started|start here]].';
+const links = parseWikiLinks(content);
+
+// Result:
+// [
+//   {
+//     raw: '[[Main Page]]',
+//     target: 'Main Page',
+//     displayText: 'Main Page',
+//     start: 4,
+//     end: 17
+//   },
+//   {
+//     raw: '[[Getting Started|start here]]',
+//     target: 'Getting Started',
+//     displayText: 'start here',
+//     start: 22,
+//     end: 52
+//   }
+// ]
+```
+
+### Supported Link Formats
+
+#### Basic Link (by title)
+```markdown
+[[Page Name]]
+```
+Links to a page by its title. Display text will be "Page Name".
+
+#### Link with Display Text
+```markdown
+[[Page Name|custom display]]
+```
+Links to "Page Name" but displays "custom display".
+
+#### Link by Slug
+```markdown
+[[page-slug-name]]
+```
+Links to a page by its URL slug (kebab-case).
+
+### Edge Cases
+
+#### Nested Brackets
+```markdown
+[[Page [with] brackets]]  ✓ Parsed correctly
+```
+Single brackets inside link text are allowed.
+
+#### Code Blocks (Not Parsed)
+```markdown
+Use `[[WikiLink]]` syntax for linking.
+
+\`\`\`typescript
+const link = "[[not parsed]]";
+\`\`\`
+```
+Links inside inline code or fenced code blocks are ignored.
+
+#### Escaped Brackets
+```markdown
+\[[not a link]] but [[real link]] works
+```
+Escaped brackets are not parsed as links.
+
+#### Empty or Invalid Links
+```markdown
+[[]]           ✗ Empty link (ignored)
+[[   ]]        ✗ Whitespace only (ignored)
+[[  Target  ]] ✓ Trimmed to "Target"
+```
+
+### Return Type
+
+```typescript
+interface WikiLink {
+  raw: string;        // Full matched text: "[[Page Name]]"
+  target: string;     // Target page: "Page Name"
+  displayText: string; // Display text: "Page Name" or custom
+  start: number;      // Start position in content
+  end: number;        // End position in content
+}
+```
+
+### Testing
+
+Comprehensive test suite (100% coverage) includes:
+- Basic parsing (single, multiple, consecutive links)
+- Display text variations
+- Edge cases (brackets, escapes, empty links)
+- Code block exclusion (inline, fenced, indented)
+- Position tracking
+- Unicode support
+- Malformed input handling
+
+Run tests:
+```bash
+pnpm test --filter=@mosaic/api -- wiki-link-parser.spec.ts
+```
+
+### Integration
+
+This parser is designed to work with the Knowledge Module's linking system:
+
+1. **On Entry Save**: Parse `[[links]]` from content
+2. **Create Link Records**: Store references in database
+3. **Backlink Tracking**: Maintain bidirectional link relationships
+4. **Link Rendering**: Replace `[[links]]` with HTML anchors
+
+See related issues:
+- #59 - Wiki-link parser (this implementation)
+- Future: Link resolution and storage
+- Future: Backlink display and navigation
+
 ## Markdown Rendering

 ### Overview
--- a/apps/api/src/knowledge/utils/wiki-link-parser.spec.ts
+++ b/apps/api/src/knowledge/utils/wiki-link-parser.spec.ts
@@ -0,0 +1,435 @@
+import { describe, it, expect } from "vitest";
+import { parseWikiLinks, WikiLink } from "./wiki-link-parser";
+
+describe("Wiki Link Parser", () => {
+  describe("Basic Parsing", () => {
+    it("should parse a simple wiki link", () => {
+      const content = "This is a [[Page Name]] in text.";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0]).toEqual({
+        raw: "[[Page Name]]",
+        target: "Page Name",
+        displayText: "Page Name",
+        start: 10,
+        end: 23,
+      });
+    });
+
+    it("should parse multiple wiki links", () => {
+      const content = "Link to [[First Page]] and [[Second Page]].";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(2);
+      expect(links[0].target).toBe("First Page");
+      expect(links[0].start).toBe(8);
+      expect(links[0].end).toBe(22);
+      expect(links[1].target).toBe("Second Page");
+      expect(links[1].start).toBe(27);
+      expect(links[1].end).toBe(42);
+    });
+
+    it("should handle empty content", () => {
+      const links = parseWikiLinks("");
+      expect(links).toEqual([]);
+    });
+
+    it("should handle content without links", () => {
+      const content = "This is just plain text with no wiki links.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should parse link by slug (kebab-case)", () => {
+      const content = "Reference to [[page-slug-name]].";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("page-slug-name");
+      expect(links[0].displayText).toBe("page-slug-name");
+    });
+  });
+
+  describe("Display Text Variation", () => {
+    it("should parse link with custom display text", () => {
+      const content = "See [[Page Name|custom display]] for details.";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0]).toEqual({
+        raw: "[[Page Name|custom display]]",
+        target: "Page Name",
+        displayText: "custom display",
+        start: 4,
+        end: 32,
+      });
+    });
+
+    it("should parse multiple links with display text", () => {
+      const content = "[[First|One]] and [[Second|Two]]";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(2);
+      expect(links[0].target).toBe("First");
+      expect(links[0].displayText).toBe("One");
+      expect(links[1].target).toBe("Second");
+      expect(links[1].displayText).toBe("Two");
+    });
+
+    it("should handle display text with special characters", () => {
+      const content = "[[Page|Click here! (details)]]";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].displayText).toBe("Click here! (details)");
+    });
+
+    it("should handle pipe character in target but default display", () => {
+      const content = "[[Page Name]]";
+      const links = parseWikiLinks(content);
+
+      expect(links[0].target).toBe("Page Name");
+      expect(links[0].displayText).toBe("Page Name");
+    });
+  });
+
+  describe("Edge Cases - Brackets", () => {
+    it("should not parse single brackets", () => {
+      const content = "This [is not] a wiki link.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should not parse three or more opening brackets", () => {
+      const content = "This [[[is not]]] a wiki link.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should not parse unmatched brackets", () => {
+      const content = "This [[is incomplete";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should not parse reversed brackets", () => {
+      const content = "This ]]not a link[[ text.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should handle nested brackets inside link text", () => {
+      const content = "[[Page [with] brackets]]";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("Page [with] brackets");
+    });
+
+    it("should handle nested double brackets", () => {
+      // This is tricky - we should parse the outer link
+      const content = "[[Outer [[inner]] link]]";
+      const links = parseWikiLinks(content);
+
+      // Should not parse nested double brackets - only the first valid one
+      expect(links).toHaveLength(1);
+      expect(links[0].raw).toBe("[[Outer [[inner]]");
+    });
+  });
+
+  describe("Edge Cases - Escaped Brackets", () => {
+    it("should not parse escaped opening brackets", () => {
+      const content = "This \\[[is not a link]] text.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should parse link after escaped brackets", () => {
+      const content = "Escaped \\[[not link]] but [[real link]] here.";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("real link");
+    });
+
+    it("should handle backslash before brackets in various positions", () => {
+      const content = "Text \\[[ and [[valid link]] more \\]].";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("valid link");
+    });
+  });
+
+  describe("Edge Cases - Code Blocks", () => {
+    it("should not parse links in inline code", () => {
+      const content = "Use `[[WikiLink]]` syntax for linking.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should not parse links in fenced code blocks", () => {
+      const content = `
+Here is some text.
+
+\`\`\`
+[[Link in code block]]
+\`\`\`
+
+End of text.
+      `;
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should not parse links in indented code blocks", () => {
+      const content = `
+Normal text here.
+
+    [[Link in indented code]]
+    More code here
+
+Normal text again.
+      `;
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should parse links outside code blocks but not inside", () => {
+      const content = `
+[[Valid Link]]
+
+\`\`\`
+[[Invalid Link]]
+\`\`\`
+
+[[Another Valid Link]]
+      `;
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(2);
+      expect(links[0].target).toBe("Valid Link");
+      expect(links[1].target).toBe("Another Valid Link");
+    });
+
+    it("should not parse links in code blocks with language", () => {
+      const content = `
+\`\`\`typescript
+const link = "[[Not A Link]]";
+\`\`\`
+      `;
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should handle multiple inline code sections", () => {
+      const content = "Use `[[link1]]` or `[[link2]]` but [[real link]] works.";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("real link");
+    });
+
+    it("should handle unclosed code backticks correctly", () => {
+      const content = "Start `code [[link1]] still in code [[link2]]";
+      const links = parseWikiLinks(content);
+      // If backtick is unclosed, we shouldn't parse any links after it
+      expect(links).toEqual([]);
+    });
+
+    it("should handle adjacent code blocks", () => {
+      const content = "`[[code1]]` text [[valid]] `[[code2]]`";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("valid");
+    });
+  });
+
+  describe("Edge Cases - Empty and Malformed", () => {
+    it("should not parse empty link brackets", () => {
+      const content = "Empty [[]] brackets.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should not parse whitespace-only links", () => {
+      const content = "Whitespace [[   ]] link.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should trim whitespace from link targets", () => {
+      const content = "Link [[  Page Name  ]] here.";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("Page Name");
+      expect(links[0].displayText).toBe("Page Name");
+    });
+
+    it("should trim whitespace from display text", () => {
+      const content = "Link [[Target|  display text  ]] here.";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("Target");
+      expect(links[0].displayText).toBe("display text");
+    });
+
+    it("should not parse link with empty target but display text", () => {
+      const content = "Link [[|display only]] here.";
+      const links = parseWikiLinks(content);
+      expect(links).toEqual([]);
+    });
+
+    it("should handle link with empty display text", () => {
+      const content = "Link [[Target|]] here.";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("Target");
+      expect(links[0].displayText).toBe("Target");
+    });
+
+    it("should handle multiple pipes", () => {
+      const content = "Link [[Target|display|extra]] here.";
+      const links = parseWikiLinks(content);
+
+      // Should use first pipe as separator
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe("Target");
+      expect(links[0].displayText).toBe("display|extra");
+    });
+  });
+
+  describe("Position Tracking", () => {
+    it("should track correct positions for single link", () => {
+      const content = "Start [[Link]] end";
+      const links = parseWikiLinks(content);
+
+      expect(links[0].start).toBe(6);
+      expect(links[0].end).toBe(14);
+      expect(content.substring(links[0].start, links[0].end)).toBe("[[Link]]");
+    });
+
+    it("should track correct positions for multiple links", () => {
+      const content = "[[First]] middle [[Second]] end";
+      const links = parseWikiLinks(content);
+
+      expect(links[0].start).toBe(0);
+      expect(links[0].end).toBe(9);
+      expect(links[1].start).toBe(17);
+      expect(links[1].end).toBe(27);
+
+      expect(content.substring(links[0].start, links[0].end)).toBe("[[First]]");
+      expect(content.substring(links[1].start, links[1].end)).toBe("[[Second]]");
+    });
+
+    it("should track positions with display text", () => {
+      const content = "Text [[Target|Display]] more";
+      const links = parseWikiLinks(content);
+
+      expect(links[0].start).toBe(5);
+      expect(links[0].end).toBe(23);
+      expect(content.substring(links[0].start, links[0].end)).toBe(
+        "[[Target|Display]]"
+      );
+    });
+
+    it("should track positions in multiline content", () => {
+      const content = `Line 1
+Line 2 [[Link]]
+Line 3`;
+      const links = parseWikiLinks(content);
+
+      expect(links[0].start).toBe(14);
+      expect(content.substring(links[0].start, links[0].end)).toBe("[[Link]]");
+    });
+  });
+
+  describe("Complex Scenarios", () => {
+    it("should handle realistic markdown content", () => {
+      const content = `
+# Knowledge Base
+
+This is a reference to [[Main Page]] and [[Getting Started|start here]].
+
+You can also check [[FAQ]] for common questions.
+
+\`\`\`typescript
+// This [[should not parse]]
+const link = "[[also not parsed]]";
+\`\`\`
+
+But [[this works]] after code block.
+      `;
+
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(4);
+      expect(links[0].target).toBe("Main Page");
+      expect(links[1].target).toBe("Getting Started");
+      expect(links[1].displayText).toBe("start here");
+      expect(links[2].target).toBe("FAQ");
+      expect(links[3].target).toBe("this works");
+    });
+
+    it("should handle links at start and end of content", () => {
+      const content = "[[Start]] middle [[End]]";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(2);
+      expect(links[0].start).toBe(0);
+      expect(links[1].end).toBe(content.length);
+    });
+
+    it("should handle consecutive links", () => {
+      const content = "[[First]][[Second]][[Third]]";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(3);
+      expect(links[0].target).toBe("First");
+      expect(links[1].target).toBe("Second");
+      expect(links[2].target).toBe("Third");
+    });
+
+    it("should handle links with unicode characters", () => {
+      const content = "Link to [[日本語]] and [[Émojis 🚀]].";
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(2);
+      expect(links[0].target).toBe("日本語");
+      expect(links[1].target).toBe("Émojis 🚀");
+    });
+
+    it("should handle very long link text", () => {
+      const longText = "A".repeat(1000);
+      const content = `Start [[${longText}]] end`;
+      const links = parseWikiLinks(content);
+
+      expect(links).toHaveLength(1);
+      expect(links[0].target).toBe(longText);
+    });
+  });
+
+  describe("Type Safety", () => {
+    it("should return correctly typed WikiLink objects", () => {
+      const content = "[[Test Link]]";
+      const links: WikiLink[] = parseWikiLinks(content);
+
+      expect(links[0]).toHaveProperty("raw");
+      expect(links[0]).toHaveProperty("target");
+      expect(links[0]).toHaveProperty("displayText");
+      expect(links[0]).toHaveProperty("start");
+      expect(links[0]).toHaveProperty("end");
+
+      expect(typeof links[0].raw).toBe("string");
+      expect(typeof links[0].target).toBe("string");
+      expect(typeof links[0].displayText).toBe("string");
+      expect(typeof links[0].start).toBe("number");
+      expect(typeof links[0].end).toBe("number");
+    });
+  });
+});
--- a/apps/api/src/knowledge/utils/wiki-link-parser.ts
+++ b/apps/api/src/knowledge/utils/wiki-link-parser.ts
@@ -0,0 +1,279 @@
+/**
+ * Represents a parsed wiki-style link from markdown content
+ */
+export interface WikiLink {
+  /** The raw matched text including brackets (e.g., "[[Page Name]]") */
+  raw: string;
+  /** The target page name or slug */
+  target: string;
+  /** The display text (may differ from target if using | syntax) */
+  displayText: string;
+  /** Start position of the link in the original content */
+  start: number;
+  /** End position of the link in the original content */
+  end: number;
+}
+
+/**
+ * Represents a region in the content that should be excluded from parsing
+ */
+interface ExcludedRegion {
+  start: number;
+  end: number;
+}
+
+/**
+ * Parse wiki-style [[links]] from markdown content.
+ *
+ * Supports:
+ * - [[Page Name]] - link by title
+ * - [[Page Name|display text]] - link with custom display
+ * - [[page-slug]] - link by slug
+ *
+ * Handles edge cases:
+ * - Nested brackets within link text
+ * - Links in code blocks (excluded from parsing)
+ * - Escaped brackets (excluded from parsing)
+ *
+ * @param content - The markdown content to parse
+ * @returns Array of parsed wiki links with position information
+ */
+export function parseWikiLinks(content: string): WikiLink[] {
+  if (!content || content.length === 0) {
+    return [];
+  }
+
+  const excludedRegions = findExcludedRegions(content);
+  const links: WikiLink[] = [];
+
+  // Manual parsing to handle complex bracket scenarios
+  let i = 0;
+  while (i < content.length) {
+    // Look for [[
+    if (i < content.length - 1 && content[i] === "[" && content[i + 1] === "[") {
+      // Check if preceded by escape character
+      if (i > 0 && content[i - 1] === "\\") {
+        i++;
+        continue;
+      }
+
+      // Check if preceded by another [ (would make [[[)
+      if (i > 0 && content[i - 1] === "[") {
+        i++;
+        continue;
+      }
+
+      // Check if followed by another [ (would make [[[)
+      if (i + 2 < content.length && content[i + 2] === "[") {
+        i++;
+        continue;
+      }
+
+      const start = i;
+      i += 2; // Skip past [[
+
+      // Find the closing ]]
+      let innerContent = "";
+      let foundClosing = false;
+
+      while (i < content.length - 1) {
+        // Check for ]]
+        if (content[i] === "]" && content[i + 1] === "]") {
+          foundClosing = true;
+          break;
+        }
+        innerContent += content[i];
+        i++;
+      }
+
+      if (!foundClosing) {
+        // No closing brackets found, continue searching
+        continue;
+      }
+
+      const end = i + 2; // Include the ]]
+      const raw = content.substring(start, end);
+
+      // Skip if this link is in an excluded region
+      if (isInExcludedRegion(start, end, excludedRegions)) {
+        i += 2; // Move past the ]]
+        continue;
+      }
+
+      // Parse the inner content to extract target and display text
+      const parsed = parseInnerContent(innerContent);
+      if (!parsed) {
+        i += 2; // Move past the ]]
+        continue;
+      }
+
+      links.push({
+        raw,
+        target: parsed.target,
+        displayText: parsed.displayText,
+        start,
+        end,
+      });
+
+      i += 2; // Move past the ]]
+    } else {
+      i++;
+    }
+  }
+
+  return links;
+}
+
+/**
+ * Parse the inner content of a wiki link to extract target and display text
+ */
+function parseInnerContent(
+  content: string
+): { target: string; displayText: string } | null {
+  // Check for pipe separator
+  const pipeIndex = content.indexOf("|");
+
+  let target: string;
+  let displayText: string;
+
+  if (pipeIndex !== -1) {
+    // Has display text
+    target = content.substring(0, pipeIndex).trim();
+    displayText = content.substring(pipeIndex + 1).trim();
+
+    // If display text is empty after trim, use target
+    if (displayText === "") {
+      displayText = target;
+    }
+  } else {
+    // No display text, target and display are the same
+    target = content.trim();
+    displayText = target;
+  }
+
+  // Reject if target is empty or whitespace-only
+  if (target === "") {
+    return null;
+  }
+
+  return { target, displayText };
+}
+
+/**
+ * Find all regions that should be excluded from wiki link parsing
+ * (code blocks, inline code, etc.)
+ */
+function findExcludedRegions(content: string): ExcludedRegion[] {
+  const regions: ExcludedRegion[] = [];
+
+  // Find fenced code blocks (``` ... ```)
+  const fencedCodePattern = /```[\s\S]*?```/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = fencedCodePattern.exec(content)) !== null) {
+    regions.push({
+      start: match.index,
+      end: match.index + match[0].length,
+    });
+  }
+
+  // Find indented code blocks (4 spaces or 1 tab at line start)
+  const lines = content.split("\n");
+  let currentIndex = 0;
+  let inIndentedBlock = false;
+  let blockStart = 0;
+
+  for (const line of lines) {
+    const lineStart = currentIndex;
+    const lineEnd = currentIndex + line.length;
+
+    // Check if line is indented (4 spaces or tab)
+    const isIndented =
+      line.startsWith("    ") || line.startsWith("\t");
+    const isEmpty = line.trim() === "";
+
+    if (isIndented && !inIndentedBlock) {
+      // Start of indented block
+      inIndentedBlock = true;
+      blockStart = lineStart;
+    } else if (!isIndented && !isEmpty && inIndentedBlock) {
+      // End of indented block (non-empty, non-indented line)
+      regions.push({
+        start: blockStart,
+        end: lineStart,
+      });
+      inIndentedBlock = false;
+    }
+
+    currentIndex = lineEnd + 1; // +1 for newline character
+  }
+
+  // Handle case where indented block extends to end of content
+  if (inIndentedBlock) {
+    regions.push({
+      start: blockStart,
+      end: content.length,
+    });
+  }
+
+  // Find inline code (` ... `)
+  // This is tricky because we need to track state
+  let inInlineCode = false;
+  let inlineStart = 0;
+
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "`") {
+      // Check if it's escaped
+      if (i > 0 && content[i - 1] === "\\") {
+        continue;
+      }
+
+      // Check if we're already in a fenced code block or indented block
+      if (isInExcludedRegion(i, i + 1, regions)) {
+        continue;
+      }
+
+      if (!inInlineCode) {
+        inInlineCode = true;
+        inlineStart = i;
+      } else {
+        // End of inline code
+        regions.push({
+          start: inlineStart,
+          end: i + 1,
+        });
+        inInlineCode = false;
+      }
+    }
+  }
+
+  // Handle unclosed inline code (extends to end of content)
+  if (inInlineCode) {
+    regions.push({
+      start: inlineStart,
+      end: content.length,
+    });
+  }
+
+  // Sort regions by start position for efficient checking
+  regions.sort((a, b) => a.start - b.start);
+
+  return regions;
+}
+
+/**
+ * Check if a position range is within any excluded region
+ */
+function isInExcludedRegion(
+  start: number,
+  end: number,
+  regions: ExcludedRegion[]
+): boolean {
+  for (const region of regions) {
+    // Check if the range overlaps with this excluded region
+    if (start < region.end && end > region.start) {
+      return true;
+    }
+  }
+  return false;
+}