302 various completion issues (#307)

* Fix issue 1

* Fix issue 3

* Fix issue 4

* Fix issue 2

* Create hungry-jars-search.md

* Update package.json

* Fix lint / format issues

* Update hungry-jars-search.md

Author: haydenbleasel

.changeset/hungry-jars-search.md

@@ -0,0 +1,8 @@
+---
+"remend": patch
+---
+
+fix: should not add closing markers to overlapping bold and italic
+fix: should handle code block with incomplete inline code after
+fix: should not add closing markers to overlapping bold and italic
+fix: should close nested underscore italic before bold

apps/website/geistdocs.tsx

@@ -47,4 +47,4 @@ export const translations = {
   },
 };
 
-export const basePath: string | undefined = undefined;
+export const basePath: string | undefined = undefined;

package.json

@@ -4,8 +4,8 @@
   "scripts": {
     "build": "turbo run build",
     "dev": "turbo run dev",
-    "check": "npx ultracite@latest check",
-    "fix": "npx ultracite@latest fix",
+    "check": "ultracite check",
+    "fix": "ultracite fix",
     "test": "turbo run test",
     "test:coverage": "turbo run test:coverage",
     "test:ui": "turbo run test:ui",

packages/remend/__tests__/bold-italic.test.ts

@@ -81,4 +81,21 @@ describe("bold-italic formatting (***)", () => {
     // Test lines 137-138: text that ends with >= 3 asterisks (but not 4+ consecutive)
     expect(remend("***word text***")).toBe("***word text***");
   });
+
+  it("should not add closing markers to overlapping bold and italic (#302)", () => {
+    // When we have **bold and *italic***, the *** is closing both ** and *
+    // It's not a bold-italic marker, so we shouldn't add closing ***
+    expect(remend("Combined **bold and *italic*** text")).toBe(
+      "Combined **bold and *italic*** text"
+    );
+    expect(remend("**bold and *italic*** more text")).toBe(
+      "**bold and *italic*** more text"
+    );
+    expect(remend("test **bold and *italic*** end")).toBe(
+      "test **bold and *italic*** end"
+    );
+    expect(remend("- Combined **bold and *italic*** text")).toBe(
+      "- Combined **bold and *italic*** text"
+    );
+  });
 });

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

@@ -1,6 +1,9 @@
 import { describe, expect, it } from "vitest";
 import remend from "../src";
 
+// Top-level regex for performance (used in multiple tests)
+const trailingDoubleUnderscorePattern = /__$/;
+
 describe("code block handling", () => {
   it("should handle incomplete multiline code blocks", () => {
     expect(remend("```javascript\nconst x = 5;")).toBe(
@@ -177,7 +180,7 @@ Notes and tips:
 
     const result = remend(input);
     expect(result).toBe(input);
-    expect(result).not.toMatch(/__$/); // Should not end with __
+    expect(result).not.toMatch(trailingDoubleUnderscorePattern); // Should not end with __
   });
 
   it("should handle complete code blocks with underscores followed by asterisk list (#300)", () => {
@@ -190,7 +193,7 @@ def __init__(self):
 
     const result = remend(input);
     expect(result).toBe(input);
-    expect(result).not.toMatch(/__$/);
+    expect(result).not.toMatch(trailingDoubleUnderscorePattern);
   });
 
   it("should handle code blocks with underscores and following text with asterisks (#300)", () => {
@@ -206,6 +209,21 @@ Some notes:
 
     const result = remend(input);
     expect(result).toBe(input);
-    expect(result).not.toMatch(/__$/);
+    expect(result).not.toMatch(trailingDoubleUnderscorePattern);
+  });
+
+  it("should handle incomplete markdown after code block (#302)", () => {
+    const text = `\`\`\`css
+code here
+\`\`\`
+
+**incomplete bold`;
+    expect(remend(text)).toBe(
+      `\`\`\`css
+code here
+\`\`\`
+
+**incomplete bold**`
+    );
   });
 });

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

@@ -56,4 +56,10 @@ describe("inline code formatting (`)", () => {
     const text5 = "text``````";
     expect(remend(text5)).toBe(text5);
   });
+
+  it("should handle code block with incomplete inline code after (#302)", () => {
+    expect(remend("```\nblock\n```\n`inline")).toBe(
+      "```\nblock\n```\n`inline`"
+    );
+  });
 });

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

@@ -64,4 +64,14 @@ describe("mixed formatting", () => {
       "**bold and *bold-italic***"
     );
   });
+
+  it("should close nested underscore italic before bold (#302)", () => {
+    // When _ opens after **, the _ should close before ** (proper nesting)
+    expect(remend("combined **_bold and italic")).toBe(
+      "combined **_bold and italic_**"
+    );
+    expect(remend("**_text")).toBe("**_text_**");
+    // When _ opens before **, the ** should close first (it's nested inside)
+    expect(remend("_italic and **bold")).toBe("_italic and **bold**_");
+  });
 });

packages/remend/__tests__/streaming.test.ts

@@ -6,8 +6,8 @@ describe("chunked streaming scenarios", () => {
     expect(remend("This is **bold with *ital")).toBe(
       "This is **bold with *ital*"
     );
-    // When bold is unclosed, it gets closed first, then underscore
-    expect(remend("**bold _und")).toBe("**bold _und**_");
+    // When underscore opens after bold, underscore should close before bold (proper nesting)
+    expect(remend("**bold _und")).toBe("**bold _und_**");
   });
 
   it("should handle headings with incomplete formatting", () => {

packages/remend/src/emphasis-handlers.ts

@@ -9,8 +9,8 @@ import {
   whitespaceOrMarkersPattern,
 } from "./patterns";
 import {
-  hasCompleteCodeBlock,
   isHorizontalRule,
+  isWithinCodeBlock,
   isWithinLinkOrImageUrl,
   isWithinMathBlock,
   isWordChar,
@@ -234,10 +234,6 @@ const shouldSkipBoldCompletion = (
 
 // Completes incomplete bold formatting (**)
 export const handleIncompleteBold = (text: string): string => {
-  if (hasCompleteCodeBlock(text)) {
-    return text;
-  }
-
   const boldMatch = text.match(boldPattern);
   if (!boldMatch) {
     return text;
@@ -246,6 +242,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)) {
+    return text;
+  }
+
   if (shouldSkipBoldCompletion(text, contentAfterMarker, markerIndex)) {
     return text;
   }
@@ -292,10 +293,6 @@ const shouldSkipItalicCompletion = (
 export const handleIncompleteDoubleUnderscoreItalic = (
   text: string
 ): string => {
-  if (hasCompleteCodeBlock(text)) {
-    return text;
-  }
-
   const italicMatch = text.match(italicPattern);
   if (!italicMatch) {
     return text;
@@ -304,6 +301,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)) {
+    return text;
+  }
+
   if (shouldSkipItalicCompletion(text, contentAfterMarker, markerIndex)) {
     return text;
   }
@@ -346,11 +348,6 @@ const findFirstSingleAsteriskIndex = (text: string): number => {
 
 // Completes incomplete italic formatting with single asterisks (*)
 export const handleIncompleteSingleAsteriskItalic = (text: string): string => {
-  // Don't process if inside a complete code block
-  if (hasCompleteCodeBlock(text)) {
-    return text;
-  }
-
   const singleAsteriskMatch = text.match(singleAsteriskPattern);
 
   if (!singleAsteriskMatch) {
@@ -363,6 +360,11 @@ export const handleIncompleteSingleAsteriskItalic = (text: string): string => {
     return text;
   }
 
+  // Check if the asterisk is within a code block
+  if (isWithinCodeBlock(text, firstSingleAsteriskIndex)) {
+    return text;
+  }
+
   // Get content after the first single asterisk
   const contentAfterFirstAsterisk = text.substring(
     firstSingleAsteriskIndex + 1
@@ -430,15 +432,43 @@ const insertClosingUnderscore = (text: string): string => {
   return `${text}_`;
 };
 
+// Helper to handle trailing ** for proper nesting of _ and ** markers
+const handleTrailingAsterisksForUnderscore = (text: string): string | null => {
+  if (!text.endsWith("**")) {
+    return null;
+  }
+
+  const textWithoutTrailingAsterisks = text.slice(0, -2);
+  const asteriskPairsAfterRemoval = (
+    textWithoutTrailingAsterisks.match(/\*\*/g) || []
+  ).length;
+
+  // If removing trailing ** makes the count odd, it was added to close an unclosed **
+  if (asteriskPairsAfterRemoval % 2 !== 1) {
+    return null;
+  }
+
+  const firstDoubleAsteriskIndex = textWithoutTrailingAsterisks.indexOf("**");
+  const underscoreIndex = findFirstSingleUnderscoreIndex(
+    textWithoutTrailingAsterisks
+  );
+
+  // If ** opened before _, then _ should close before **
+  if (
+    firstDoubleAsteriskIndex !== -1 &&
+    underscoreIndex !== -1 &&
+    firstDoubleAsteriskIndex < underscoreIndex
+  ) {
+    return `${textWithoutTrailingAsterisks}_**`;
+  }
+
+  return null;
+};
+
 // Completes incomplete italic formatting with single underscores (_)
 export const handleIncompleteSingleUnderscoreItalic = (
   text: string
 ): string => {
-  // Don't process if inside a complete code block
-  if (hasCompleteCodeBlock(text)) {
-    return text;
-  }
-
   const singleUnderscoreMatch = text.match(singleUnderscorePattern);
 
   if (!singleUnderscoreMatch) {
@@ -451,6 +481,11 @@ export const handleIncompleteSingleUnderscoreItalic = (
     return text;
   }
 
+  // Check if the underscore is within a code block
+  if (isWithinCodeBlock(text, firstSingleUnderscoreIndex)) {
+    return text;
+  }
+
   // Get content after the first single underscore
   const contentAfterFirstUnderscore = text.substring(
     firstSingleUnderscoreIndex + 1
@@ -467,49 +502,72 @@ export const handleIncompleteSingleUnderscoreItalic = (
 
   const singleUnderscores = countSingleUnderscores(text);
   if (singleUnderscores % 2 === 1) {
+    // Check if we need to insert _ before trailing ** for proper nesting
+    const trailingResult = handleTrailingAsterisksForUnderscore(text);
+    if (trailingResult !== null) {
+      return trailingResult;
+    }
     return insertClosingUnderscore(text);
   }
 
   return text;
 };
 
-// Completes incomplete bold-italic formatting (***)
-export const handleIncompleteBoldItalic = (text: string): string => {
-  // Don't process if inside a complete code block
-  if (hasCompleteCodeBlock(text)) {
-    return text;
+// Helper to check if bold-italic markers are already balanced
+const areBoldItalicMarkersBalanced = (text: string): boolean => {
+  const asteriskPairs = (text.match(/\*\*/g) || []).length;
+  const singleAsterisks = countSingleAsterisks(text);
+  return asteriskPairs % 2 === 0 && singleAsterisks % 2 === 0;
+};
+
+// Helper to check if bold-italic should be skipped
+const shouldSkipBoldItalicCompletion = (
+  text: string,
+  contentAfterMarker: string,
+  markerIndex: number
+): boolean => {
+  if (
+    !contentAfterMarker ||
+    whitespaceOrMarkersPattern.test(contentAfterMarker)
+  ) {
+    return true;
   }
 
+  if (isWithinCodeBlock(text, markerIndex)) {
+    return true;
+  }
+
+  return isHorizontalRule(text, markerIndex, "*");
+};
+
+// Completes incomplete bold-italic formatting (***)
+export const handleIncompleteBoldItalic = (text: string): string => {
   // Don't process if text is only asterisks and has 4 or more consecutive asterisks
-  // This prevents cases like **** from being treated as incomplete ***
   if (fourOrMoreAsterisksPattern.test(text)) {
     return text;
   }
 
   const boldItalicMatch = text.match(boldItalicPattern);
 
-  if (boldItalicMatch) {
-    // Don't close if there's no meaningful content after the opening markers
-    // boldItalicMatch[2] contains the content after ***
-    // Check if content is only whitespace or other emphasis markers
-    const contentAfterMarker = boldItalicMatch[2];
-    if (
-      !contentAfterMarker ||
-      whitespaceOrMarkersPattern.test(contentAfterMarker)
-    ) {
-      return text;
-    }
+  if (!boldItalicMatch) {
+    return text;
+  }
 
-    // Check if the *** is a horizontal rule
-    const markerIndex = text.lastIndexOf(boldItalicMatch[1]);
-    if (isHorizontalRule(text, markerIndex, "*")) {
-      return text;
-    }
+  const contentAfterMarker = boldItalicMatch[2];
+  const markerIndex = text.lastIndexOf(boldItalicMatch[1]);
 
-    const tripleAsteriskCount = countTripleAsterisks(text);
-    if (tripleAsteriskCount % 2 === 1) {
-      return `${text}***`;
+  if (shouldSkipBoldItalicCompletion(text, contentAfterMarker, markerIndex)) {
+    return text;
+  }
+
+  const tripleAsteriskCount = countTripleAsterisks(text);
+  if (tripleAsteriskCount % 2 === 1) {
+    // If both ** and * are balanced, don't add closing ***
+    // The *** is likely overlapping markers (e.g., **bold and *italic***)
+    if (areBoldItalicMarkersBalanced(text)) {
+      return text;
     }
+    return `${text}***`;
   }
 
   return text;