fix(confluence): fix nested-block duplication in callout text extraction

Greptile P1: filtering the found blocks to only top-level ones still wasn't
enough — a nested block (an outer <li> containing its own nested <ul><li>, a
<td> containing a <blockquote>) matched the selector once, but its .text()
call recurses into and flattens its own matched descendants with no
separator, reproducing the exact word-fusion bug one level deeper (and any
duplicate-selection would have double-counted the same text).

Replaces the block-selector approach with a recursive text-node walk:
extractBlockJoinedText now visits every text node individually and joins them
all with a single space, so word boundaries are preserved at every nesting
depth with no double-counting, matching the pattern html-parser.ts already
uses elsewhere in this codebase for the same class of problem.

Author: waleedlatif1

apps/sim/connectors/confluence/confluence.test.ts

@@ -163,4 +163,35 @@ describe('preserveConfluenceCallouts', () => {
       expect(result).not.toContain('sentence.Second')
     }
   )
+
+  it.concurrent(
+    'does not duplicate or fuse text from a nested list inside a callout body (nesting regression)',
+    () => {
+      const html =
+        '<div class="confluence-information-macro confluence-information-macro-note">' +
+        '<div class="confluence-information-macro-body">' +
+        '<ul><li>Outer item' +
+        '<ul><li>Nested item A</li><li>Nested item B</li></ul>' +
+        '</li><li>Outer item two</li></ul>' +
+        '</div></div>'
+      const result = preserveConfluenceCallouts(html)
+      // Each nested <li>'s text must appear exactly once, not duplicated by the
+      // outer <li> also being matched and its .text() recursing into it.
+      const occurrences = (result.match(/Nested item A/g) ?? []).length
+      expect(occurrences).toBe(1)
+      expect(result).not.toContain('Nested item ANested item B')
+      expect(result).toContain('Outer item Nested item A Nested item B Outer item two')
+    }
+  )
+
+  it.concurrent('does not fuse text from a blockquote nested inside a table cell', () => {
+    const html =
+      '<div class="panel"><div class="panelContent">' +
+      '<table><tr><td>Cell text<blockquote><p>quoted text</p></blockquote>after quote</td></tr></table>' +
+      '</div></div>'
+    const result = preserveConfluenceCallouts(html)
+    expect(result).not.toContain('quotedtext')
+    expect(result).not.toContain('textafter')
+    expect(result).toContain('Cell text quoted text after quote')
+  })
 })

apps/sim/connectors/confluence/confluence.ts

@@ -19,28 +19,34 @@ const CALLOUT_LABELS: Record<string, string> = {
 }
 
 /**
- * Selectors for elements whose own text is a natural word-boundary unit —
- * paragraphs, list items, headings, table cells, quotes. Cheerio's `.text()`
- * concatenates every descendant text node with no separator at all, so pulling
- * a macro body's text in one call fuses adjacent blocks together (e.g. a
- * `<p>...for:</p>` immediately followed by `<li>GitLab</li>` becomes
- * `for:GitLab`, corrupting the very word boundaries RAG chunking depends on).
- * Extracting block-by-block and joining with a single space keeps each block's
- * text intact and separated, matching how `htmlToPlainText` already treats the
- * rest of the page.
+ * Cheerio's `.text()` concatenates every descendant text node with no
+ * separator at all, so pulling a macro body's text in one call fuses adjacent
+ * blocks together (e.g. a `<p>...for:</p>` immediately followed by
+ * `<li>GitLab</li>` becomes `for:GitLab`, corrupting the very word boundaries
+ * RAG chunking depends on). Selecting "block" elements and taking `.text()` on
+ * each independently isn't enough either — nested blocks (a `<li>` containing
+ * its own nested `<ul><li>`, a `<td>` containing a `<blockquote>`) still fuse
+ * together the same way, one level deeper, since a matched outer block's
+ * `.text()` recurses into and flattens its matched descendants too. Walking
+ * every text node individually and joining them all with a single space
+ * fixes both cases at once, with no double-counting, regardless of nesting
+ * depth — matching how `html-parser.ts` already walks HTML for the same
+ * reason elsewhere in this codebase.
  */
-const BLOCK_TEXT_SELECTOR = 'p, li, h1, h2, h3, h4, h5, h6, td, th, blockquote, pre'
-
 function extractBlockJoinedText($: cheerio.CheerioAPI, $el: cheerio.Cheerio<any>): string {
-  const blocks = $el.find(BLOCK_TEXT_SELECTOR)
-  if (blocks.length === 0) {
-    return $el.text().trim()
+  const parts: string[] = []
+  const visit = ($node: cheerio.Cheerio<any>) => {
+    $node.contents().each((_, child) => {
+      if (child.type === 'text') {
+        const text = $(child).text().trim()
+        if (text) parts.push(text)
+      } else if (child.type === 'tag') {
+        visit($(child))
+      }
+    })
   }
-  return blocks
-    .map((_, block) => $(block).text().trim())
-    .get()
-    .filter(Boolean)
-    .join(' ')
+  visit($el)
+  return parts.join(' ').trim()
 }
 
 /**