fix(shared): file links with parentheses in the path keep their parent folder labels

apps/web/src/components/ChatMarkdown.tsx

@@ -2,6 +2,7 @@ import { buildFileLinkParentSuffixByPath, fileLinkLabel } from "@t3tools/shared/
 import {
   isWindowsDrivePathHref,
   normalizeMarkdownLinkDestination,
+  decodeMarkdownLinkEscapes,
   extractInlineCodeSpans,
   extractMarkdownLinkHrefs,
   inlineCodeFilePathCandidate,
@@ -455,6 +456,7 @@ function fileLinkSourcesKey(
 ): string {
   const hrefs = extractMarkdownLinkHrefs(renderCodexInlineDirectivesAsMarkdown(text))
     .filter((href) => !parseComposerContextHref(href))
+    .map(decodeMarkdownLinkEscapes)
     .map(normalizeMarkdownLinkHrefKey)
     .filter((href) => resolveMarkdownFileLinkMeta(href, cwd, imageBaseDir ?? cwd));
   const spans = extractInlineCodeSpans(text).filter((span) =>

packages/shared/src/markdownLinks.test.ts

@@ -102,6 +102,21 @@ describe("extractMarkdownLinkHrefs", () => {
   ])("extracts links from incomplete and nested text", (markdown, hrefs) => {
     expect(extractMarkdownLinkHrefs(markdown)).toEqual(hrefs);
   });
+
+  it.each([
+    [
+      "[a](/x/app/(a)/page.tsx) [b](/x/app/(b)/page.tsx)",
+      ["/x/app/(a)/page.tsx", "/x/app/(b)/page.tsx"],
+    ],
+    ['[a](/tmp/a(1).txt "title") after', ["/tmp/a(1).txt"]],
+    ["[a](a(b(c))d) [b](ok)", ["a(b(c))d", "ok"]],
+    ["[a](x\\)y) [b](x\\(y)", ["x\\)y", "x\\(y"]],
+    ["[a](unclosed(paren) [b](ok)", ["ok"]],
+    ["[a](" + "(".repeat(32) + "x" + ")".repeat(32) + ")", ["(".repeat(32) + "x" + ")".repeat(32)]],
+    ["[a](" + "(".repeat(33) + "x" + ")".repeat(33) + ") [b](ok)", ["ok"]],
+  ])("keeps balanced parentheses in a destination like the parser: %s", (markdown, hrefs) => {
+    expect(extractMarkdownLinkHrefs(markdown)).toEqual(hrefs);
+  });
 });
 
 describe("resolveMarkdownFileLinkTarget", () => {

packages/shared/src/markdownLinks.ts

@@ -356,10 +356,33 @@ function markdownLinkTailScanner(markdown: string) {
   };
 }
 
+// micromark's own nesting limit. It also keeps link scanning linear: a scan only runs past another
+// link's opening parenthesis while that parenthesis counts toward this depth.
+const MAX_BARE_DESTINATION_PAREN_DEPTH = 32;
+
+function bareMarkdownLinkDestinationEnd(markdown: string, start: number): number | null {
+  const delimiter = /[\s()\\]/g;
+  delimiter.lastIndex = start;
+  let depth = 0;
+  while (true) {
+    const index = delimiter.exec(markdown)?.index ?? markdown.length;
+    const char = markdown[index];
+    if (char === "\\") {
+      if (/[()\\]/.test(markdown[index + 1] ?? "")) delimiter.lastIndex = index + 2;
+    } else if (char === "(") {
+      if (depth === MAX_BARE_DESTINATION_PAREN_DEPTH) return null;
+      depth += 1;
+    } else if (char === ")" && depth > 0) {
+      depth -= 1;
+    } else {
+      return depth === 0 ? index : null;
+    }
+  }
+}
+
 function markdownLinkDestinationScanner(markdown: string) {
   const whitespaceEnd = markdownRunEndFinder(markdown, /\S/g);
   const angleEnd = markdownRunEndFinder(markdown, /[>\n]/g);
-  const bareEnd = markdownRunEndFinder(markdown, /[\s)]/g);
   // Separate caches keep scans moving forward when angle destinations fall back to bare ones.
   const angleTail = markdownLinkTailScanner(markdown);
   const bareTail = markdownLinkTailScanner(markdown);
@@ -373,13 +396,18 @@ function markdownLinkDestinationScanner(markdown: string) {
         if (end !== null) return { hrefStart: hrefStart + 1, hrefEnd, end };
       }
     }
-    const hrefEnd = bareEnd(hrefStart);
-    if (hrefEnd === hrefStart) return null;
+    const hrefEnd = bareMarkdownLinkDestinationEnd(markdown, hrefStart);
+    if (hrefEnd === null || hrefEnd === hrefStart) return null;
     const end = bareTail(hrefEnd);
     return end === null ? null : { hrefStart, hrefEnd, end };
   };
 }
 
+export function decodeMarkdownLinkEscapes(href: string): string {
+  if (isWindowsAbsolutePath(href) && !href.includes("&")) return href;
+  return href.replace(/\\([!-/:-@[-`{-~])/g, "$1");
+}
+
 export function extractMarkdownLinkHrefs(markdown: string): string[] {
   const hrefs: string[] = [];
   const scanDestination = markdownLinkDestinationScanner(markdown);

packages/shared/src/threadFindText.test.ts

@@ -79,6 +79,20 @@ it("searches displayed prose and file-chip labels without hidden paths", () => {
     "label main.ts · L3:C2",
   ]);
   expect(assistantSegments("[label](src/main.ts#L3C2)")).toEqual(["label"]);
+  for (const text of [
+    "[a](/repo/app/(a)/page.tsx) and [b](/repo/app/(b)/page.tsx)",
+    String.raw`[a](/repo/app/\(a\)/page.tsx) and [b](/repo/app/\(b\)/page.tsx)`,
+  ]) {
+    expect(assistantSegments(text, "/repo")).toEqual([
+      "a page.tsx · app/(a) and b page.tsx · app/(b)",
+    ]);
+  }
+  expect(
+    assistantSegments(
+      String.raw`[a](C:\repo\.a\page.tsx) and [b](C:\repo\.b\page.tsx)`,
+      String.raw`C:\repo`,
+    ),
+  ).toEqual(["a page.tsx · repo/.a and b page.tsx · repo/.b"]);
 });
 
 it("keeps fence paths literal and indexes file-chip labels in user messages", () => {

packages/shared/src/threadFindText.ts

@@ -15,6 +15,7 @@ import {
 } from "./fileLinks.ts";
 import {
   isMarkdownFileLinkLabel,
+  decodeMarkdownLinkEscapes,
   extractMarkdownLinkHrefs,
   extractInlineCodeSpans,
   inlineCodeFilePathCandidate,
@@ -119,7 +120,9 @@ function markdownThreadFindText(
       : assistantProcessor;
   const tree = processor.runSync(processor.parse(markdown));
   const paths = [
-    ...extractMarkdownLinkHrefs(renderCodexInlineDirectivesAsMarkdown(markdown)),
+    ...extractMarkdownLinkHrefs(renderCodexInlineDirectivesAsMarkdown(markdown)).map(
+      decodeMarkdownLinkEscapes,
+    ),
     ...extractInlineCodeSpans(markdown).flatMap((span) => inlineCodeFilePathCandidate(span) ?? []),
   ].flatMap((href) => {
     const target = resolveMarkdownFileLinkTarget(href, cwd);