fix(remend): don't complete emphasis/strikethrough markers inside complete inline code spans (#426)

* fix(remend): don't complete bold/italic/strikethrough inside complete inline code spans

Bold, italic, and strikethrough handlers were using isWithinCodeBlock()
which only detects triple-backtick fenced code blocks. Markers inside
single-backtick inline code spans (e.g. `**bold`) were incorrectly
completed, leaking outside the code span.

Fix:
- Add isWithinCompleteInlineCode() to code-block-utils.ts that returns
  true only when a position is inside a *complete* (both delimiters
  present) inline code span. This preserves the existing streaming
  behavior where emphasis inside an *incomplete* inline code span
  (still being streamed) continues to be closed correctly.
- Apply the check in handleIncompleteBold, handleIncompleteBoldItalic,
  handleIncompleteDoubleUnderscoreItalic, handleIncompleteSingleAsterisk-
  Italic, and handleIncompleteStrikethrough.

Fixes #424

* fix(remend): add isWithinCompleteInlineCode guard to handleIncompleteSingleUnderscoreItalic

* chore: add changeset for inline code emphasis fix

---------

Co-authored-by: Dmitrii Troitskii <jsleitor@gmail.com>

Author: sleitor

.changeset/fix-inline-code-emphasis.md

@@ -0,0 +1,5 @@
+---
+"remend": patch
+---
+
+fix: don't complete bold/italic/strikethrough markers inside complete inline code spans

packages/remend/__tests__/inline-code.test.ts

@@ -63,3 +63,21 @@ describe("inline code formatting (`)", () => {
     );
   });
 });
+
+describe("emphasis markers inside inline code spans should not leak", () => {
+  it("should not complete bold/italic/strikethrough if they are inside inline code", () => {
+    expect(remend("`**bold`")).toBe("`**bold`");
+    expect(remend("`*italic`")).toBe("`*italic`");
+    expect(remend("`~~strikethrough`")).toBe("`~~strikethrough`");
+  });
+
+  it("should still complete emphasis markers outside inline code", () => {
+    expect(remend("**bold")).toBe("**bold**");
+    expect(remend("*italic")).toBe("*italic*");
+    expect(remend("~~strike")).toBe("~~strike~~");
+  });
+
+  it("should complete emphasis after a closed inline code span", () => {
+    expect(remend("`code` **bold")).toBe("`code` **bold**");
+  });
+});

packages/remend/__tests__/mixed-formatting.test.ts

@@ -50,7 +50,7 @@ describe("mixed formatting", () => {
   it("should handle deeply nested incomplete formatting", () => {
     // Formats are closed in the order they're processed
     expect(remend("**bold *italic `code ~~strike")).toBe(
-      "**bold *italic `code ~~strike*`~~"
+      "**bold *italic `code ~~strike*`"
     );
   });
 

packages/remend/src/code-block-utils.ts

@@ -40,3 +40,40 @@ export const countSingleBackticks = (text: string): number => {
   }
   return count;
 };
+
+// Check if a position is inside a COMPLETE inline code span (both opening and closing backtick present).
+// Returns false for incomplete inline code spans (streaming) so emphasis markers can still be completed.
+export const isWithinCompleteInlineCode = (
+  text: string,
+  position: number
+): boolean => {
+  let inInlineCode = false;
+  let inMultilineCode = false;
+  let inlineCodeStart = -1;
+
+  for (let i = 0; i < text.length; i += 1) {
+    // Check for triple backticks (multiline code blocks)
+    if (text.substring(i, i + 3) === "```") {
+      inMultilineCode = !inMultilineCode;
+      i += 2;
+      continue;
+    }
+
+    // Only check for inline code if not in multiline code
+    if (!inMultilineCode && text[i] === "`") {
+      if (inInlineCode) {
+        // Found closing backtick — check if position is inside this complete span
+        if (inlineCodeStart < position && position < i) {
+          return true;
+        }
+        inInlineCode = false;
+        inlineCodeStart = -1;
+      } else {
+        inInlineCode = true;
+        inlineCodeStart = i;
+      }
+    }
+  }
+
+  return false;
+};

packages/remend/src/emphasis-handlers.ts

@@ -1,3 +1,7 @@
+import {
+  isInsideCodeBlock,
+  isWithinCompleteInlineCode,
+} from "./code-block-utils";
 import {
   boldItalicPattern,
   boldPattern,
@@ -11,7 +15,6 @@ import {
 } from "./patterns";
 import {
   isHorizontalRule,
-  isWithinCodeBlock,
   isWithinHtmlTag,
   isWithinLinkOrImageUrl,
   isWithinMathBlock,
@@ -340,8 +343,11 @@ export const handleIncompleteBold = (text: string): string => {
   const contentAfterMarker = boldMatch[2];
   const markerIndex = text.lastIndexOf(boldMatch[1]);
 
-  // Check if the bold marker is within a code block
-  if (isWithinCodeBlock(text, markerIndex)) {
+  // Check if the bold marker is within a code block (fenced or inline)
+  if (
+    isInsideCodeBlock(text, markerIndex) ||
+    isWithinCompleteInlineCode(text, markerIndex)
+  ) {
     return text;
   }
 
@@ -404,7 +410,12 @@ export const handleIncompleteDoubleUnderscoreItalic = (
     const halfCompleteMatch = text.match(halfCompleteUnderscorePattern);
     if (halfCompleteMatch) {
       const markerIndex = text.lastIndexOf(halfCompleteMatch[1]);
-      if (!isWithinCodeBlock(text, markerIndex)) {
+      if (
+        !(
+          isInsideCodeBlock(text, markerIndex) ||
+          isWithinCompleteInlineCode(text, markerIndex)
+        )
+      ) {
         const underscorePairs = countDoubleUnderscoresOutsideCodeBlocks(text);
         if (underscorePairs % 2 === 1) {
           return `${text}_`;
@@ -417,8 +428,11 @@ export const handleIncompleteDoubleUnderscoreItalic = (
   const contentAfterMarker = italicMatch[2];
   const markerIndex = text.lastIndexOf(italicMatch[1]);
 
-  // Check if the italic marker is within a code block
-  if (isWithinCodeBlock(text, markerIndex)) {
+  // Check if the italic marker is within a code block (fenced or inline)
+  if (
+    isInsideCodeBlock(text, markerIndex) ||
+    isWithinCompleteInlineCode(text, markerIndex)
+  ) {
     return text;
   }
 
@@ -506,6 +520,14 @@ export const handleIncompleteSingleAsteriskItalic = (text: string): string => {
     return text;
   }
 
+  // Don't close if the marker is inside a complete inline code span or fenced code block
+  if (
+    isInsideCodeBlock(text, firstSingleAsteriskIndex) ||
+    isWithinCompleteInlineCode(text, firstSingleAsteriskIndex)
+  ) {
+    return text;
+  }
+
   // Get content after the first single asterisk
   const contentAfterFirstAsterisk = text.substring(
     firstSingleAsteriskIndex + 1
@@ -655,6 +677,10 @@ export const handleIncompleteSingleUnderscoreItalic = (
     return text;
   }
 
+  if (isWithinCompleteInlineCode(text, firstSingleUnderscoreIndex)) {
+    return text;
+  }
+
   const singleUnderscores = countSingleUnderscores(text);
   if (singleUnderscores % 2 === 1) {
     // Check if we need to insert _ before trailing ** for proper nesting
@@ -688,7 +714,10 @@ const shouldSkipBoldItalicCompletion = (
     return true;
   }
 
-  if (isWithinCodeBlock(text, markerIndex)) {
+  if (
+    isInsideCodeBlock(text, markerIndex) ||
+    isWithinCompleteInlineCode(text, markerIndex)
+  ) {
     return true;
   }
 

packages/remend/src/strikethrough-handler.ts

@@ -1,3 +1,7 @@
+import {
+  isInsideCodeBlock,
+  isWithinCompleteInlineCode,
+} from "./code-block-utils";
 import {
   doubleTildeGlobalPattern,
   halfCompleteTildePattern,
@@ -21,6 +25,15 @@ export const handleIncompleteStrikethrough = (text: string): string => {
       return text;
     }
 
+    // Don't close if the marker is inside an inline code span or fenced code block
+    const markerIndex = text.lastIndexOf(strikethroughMatch[1]);
+    if (
+      isInsideCodeBlock(text, markerIndex) ||
+      isWithinCompleteInlineCode(text, markerIndex)
+    ) {
+      return text;
+    }
+
     // doubleTildeGlobalPattern always matches when strikethroughPattern matched
     const tildePairs = text.match(doubleTildeGlobalPattern)?.length;
     if (tildePairs % 2 === 1) {
@@ -31,6 +44,14 @@ export const handleIncompleteStrikethrough = (text: string): string => {
     // The pattern /(~~)([^~]*?)$/ won't match ~~content~ because it ends with ~
     const halfCompleteMatch = text.match(halfCompleteTildePattern);
     if (halfCompleteMatch) {
+      // Don't close if the marker is inside an inline code span or fenced code block
+      const markerIndex = text.lastIndexOf(halfCompleteMatch[0].slice(0, 2));
+      if (
+        isInsideCodeBlock(text, markerIndex) ||
+        isWithinCompleteInlineCode(text, markerIndex)
+      ) {
+        return text;
+      }
       // doubleTildeGlobalPattern always matches when halfCompleteTildePattern matched
       const tildePairs = text.match(doubleTildeGlobalPattern)?.length;
       if (tildePairs % 2 === 1) {