fix(confluence): distinguish inline formatting from block boundaries in extraction

Greptile: the recursive text-node walk unconditionally inserted a space
between every text node, which fixed block-boundary fusion but broke
genuinely inline-formatted text — "un<b>believe</b>able" became
"un believe able" and "Hello<b>!</b>" became "Hello !", corrupting valid
callout content on its way into the index.

Adds an INLINE_FORMATTING_TAGS allowlist (b, strong, i, em, span, a, etc.):
text flowing through those tags accumulates with no artificial separator,
preserving exact source adjacency, while every other tag boundary (p, li,
td, headings, br, ...) still flushes to a new segment — a block always
implies a break even with no literal whitespace in the source, but an inline
tag never does. Fixed one test that had encoded the old, incorrect
expectation for two genuinely adjacent inline tags with no source whitespace
between them, and added regression tests for mid-word inline formatting,
punctuation attached to an inline tag, and a header with real source spacing.

Author: waleedlatif1

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

@@ -110,15 +110,25 @@ describe('preserveConfluenceCallouts', () => {
     expect(result).toContain('GitLab access requests go to the private channel instead.')
   })
 
-  it.concurrent('preserves word boundaries in a rich, multi-node Panel header', () => {
+  it.concurrent('preserves word boundaries between a block header and its own content', () => {
     const html =
-      '<div class="panel"><div class="panelHeader"><b>Warning:</b><span>Do not use</span></div>' +
+      '<div class="panel"><div class="panelHeader"><b>Warning:</b></div>' +
       '<div class="panelContent"><p>See replacement form.</p></div></div>'
     const result = preserveConfluenceCallouts(html)
-    expect(result).not.toContain('Warning:Do')
-    expect(result).toContain('[CALLOUT: Warning: Do not use]')
+    expect(result).toContain('[CALLOUT: Warning:] See replacement form.')
   })
 
+  it.concurrent(
+    'keeps a rich header with a real source space intact, without adding a second one',
+    () => {
+      const html =
+        '<div class="panel"><div class="panelHeader"><b>Warning:</b> <span>Do not use</span></div>' +
+        '<div class="panelContent"><p>See replacement form.</p></div></div>'
+      const result = preserveConfluenceCallouts(html)
+      expect(result).toContain('[CALLOUT: Warning: Do not use]')
+    }
+  )
+
   it.concurrent('falls back to a bare CALLOUT label when a Panel macro has no header text', () => {
     const html =
       '<div class="panel"><div class="panelContent"><p>Untitled panel body.</p></div></div>'
@@ -203,4 +213,36 @@ describe('preserveConfluenceCallouts', () => {
     expect(result).not.toContain('textafter')
     expect(result).toContain('Cell text quoted text after quote')
   })
+
+  it.concurrent(
+    'does not inject an artificial space into inline-formatted text mid-word (inline vs. block regression)',
+    () => {
+      const html =
+        '<div class="panel"><div class="panelContent">' +
+        '<p>This is un<b>believe</b>able.</p>' +
+        '</div></div>'
+      const result = preserveConfluenceCallouts(html)
+      expect(result).not.toContain('un believe able')
+      expect(result).toContain('This is unbelieveable.')
+    }
+  )
+
+  it.concurrent('does not inject a space before punctuation carried by an inline tag', () => {
+    const html =
+      '<div class="confluence-information-macro confluence-information-macro-warning">' +
+      '<div class="confluence-information-macro-body"><p>Do not proceed<b>!</b></p></div>' +
+      '</div>'
+    const result = preserveConfluenceCallouts(html)
+    expect(result).not.toContain('proceed !')
+    expect(result).toContain('[WARNING] Do not proceed!')
+  })
+
+  it.concurrent('keeps natural word spacing when inline tags wrap a whole word', () => {
+    const html =
+      '<div class="panel"><div class="panelContent">' +
+      '<p>Do <b>NOT</b> use this form.</p>' +
+      '</div></div>'
+    const result = preserveConfluenceCallouts(html)
+    expect(result).toContain('Do NOT use this form.')
+  })
 })

apps/sim/connectors/confluence/confluence.ts

@@ -18,34 +18,83 @@ const CALLOUT_LABELS: Record<string, string> = {
   error: '[ERROR]',
 }
 
+/**
+ * Inline formatting tags whose text flows directly into their surrounding
+ * sentence with no implied word break — e.g. `un<b>believe</b>able` must stay
+ * `unbelievable`, and `Hello<b>!</b>` must stay `Hello!`, not gain an
+ * artificial space. Anything not in this set (p, li, td, div, headings, br,
+ * etc.) is treated as a block boundary that always implies a break, even when
+ * the source HTML has no literal whitespace there.
+ */
+const INLINE_FORMATTING_TAGS = new Set([
+  'b',
+  'strong',
+  'i',
+  'em',
+  'u',
+  's',
+  'strike',
+  'del',
+  'ins',
+  'sup',
+  'sub',
+  'small',
+  'mark',
+  'code',
+  'span',
+  'a',
+  'abbr',
+  'cite',
+  'q',
+  'kbd',
+  'var',
+  'samp',
+  'time',
+])
+
 /**
  * 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.
+ * RAG chunking depends on). Simply joining every text node with a space isn't
+ * right either — that would corrupt genuinely inline-formatted text the same
+ * way. This walks the DOM, accumulating text through inline tags without a
+ * separator (preserving exact source adjacency) and flushing to a new segment
+ * at every other tag boundary (a block always implies a break, regardless of
+ * source whitespace) — matching how `html-parser.ts` already walks HTML for a
+ * related reason elsewhere in this codebase, extended with the inline/block
+ * distinction real Confluence rich text requires.
  */
 function extractBlockJoinedText($: cheerio.CheerioAPI, $el: cheerio.Cheerio<any>): string {
   const parts: string[] = []
+  let current = ''
+
+  const flush = () => {
+    const text = current.trim()
+    if (text) parts.push(text)
+    current = ''
+  }
+
   const visit = ($node: cheerio.Cheerio<any>) => {
     $node.contents().each((_, child) => {
       if (child.type === 'text') {
-        const text = $(child).text().trim()
-        if (text) parts.push(text)
+        current += $(child).text()
       } else if (child.type === 'tag') {
-        visit($(child))
+        const tag = child.tagName?.toLowerCase()
+        if (tag && INLINE_FORMATTING_TAGS.has(tag)) {
+          visit($(child))
+        } else {
+          flush()
+          visit($(child))
+          flush()
+        }
       }
     })
   }
+
   visit($el)
+  flush()
   return parts.join(' ').trim()
 }