slack-markdown-parser 2.4.3__tar.gz → 2.4.4__tar.gz

{slack_markdown_parser-2.4.3 → slack_markdown_parser-2.4.4}/CHANGELOG.md

@@ -6,6 +6,13 @@ The format is based on Keep a Changelog, and the project follows Semantic Versio
 
 ## [Unreleased]
 
+## [2.4.4] - 2026-06-10
+
+### Fixed
+
+- Stopped a link wrapped entirely in emphasis (`**[text](url)**`, and the `*`/`_`/`__`/`~~`/`***` variants) from rendering as dead, literal text in `rich_text` contexts such as list items and table cells. The emphasis token pattern matched the whole `**[text](url)**` span before the link pattern got a chance, so `_create_rich_text_inline_elements` emitted the inner `[text](url)` as a styled plain-text run and the link was never clickable. When a styled (non-code) token's inner content is itself a complete markdown link, it now becomes a `link` element carrying that style (e.g. a bold link), matching the already-working emphasis-inside-the-brackets form (`[**text**](url)`).
+- Stopped Slack mention tokens from rendering as literal text inside promoted list items. Since 2.4.0 a simple list is emitted as a `rich_text` block, but the inline builder only tokenized links, code, and emphasis — so a `<#C123>` / `<@U123>` / `<!subteam^S123>` / `<!here>` token in a list item fell through as a plain `text` run. In a `rich_text` block a mention has to be a structured element (`channel`, `user`, `usergroup`, `broadcast`), so Slack showed the raw `<#C123>` rather than a pill. (Prose was unaffected: it stays in a `markdown` block, where Slack resolves the token itself.) These tokens are now converted to the matching rich_text elements, an optional `|label` display suffix is dropped (Slack renders the element from the id), and the plain-text fallback re-emits the canonical `<#C123>` token so a downgraded mrkdwn fallback still links and notifies. The same applies inside table cells: `extract_plain_text_from_table_cell` now delegates inline runs to the shared rich_text downgrade path instead of a separate near-copy, so a mention in a cell also survives into the fallback text rather than vanishing.
+
 ## [2.4.3] - 2026-05-29
 
 ### Fixed

{slack_markdown_parser-2.4.3/slack_markdown_parser.egg-info → slack_markdown_parser-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-markdown-parser
-Version: 2.4.3
+Version: 2.4.4
 Summary: Convert LLM Markdown into Slack Block Kit messages
 Author: darkgaldragon
 License-Expression: MIT

{slack_markdown_parser-2.4.3 → slack_markdown_parser-2.4.4}/docs/spec.md

@@ -81,6 +81,7 @@ Slack still controls when those newer features appear and how they look, so trea
   - simple one-level quotes to `rich_text_quote`
   - simple bullet and ordered lists to `rich_text_list`
     - Lists are promoted only when the list starts at the beginning of the text region or after a blank line, each non-blank line in the run is a list item, the list does not use ambiguous 1-3-space nested indentation, the item text does not rely on Markdown backslash escapes, and the run is not followed by an indented continuation paragraph.
+    - Slack mention tokens inside a promoted list item are converted to their structured `rich_text` elements — `<@U…>`/`<@W…>` to `user`, `<#C…>`/`<#G…>` to `channel`, `<!subteam^S…>` to `usergroup`, and `<!here>`/`<!channel>`/`<!everyone>` to `broadcast` — since a `rich_text` block does not resolve a raw token. An optional `|label` display suffix is dropped (Slack renders the element from the id).
 - Table-like rows inside fenced code blocks are kept out of table parsing
 - Internal blank lines can optionally be rewritten into placeholder lines so Slack keeps visible paragraph separation
 - Unsupported Slack angle-bracket tokens such as `<foo>` or raw HTML-like tags are neutralized

{slack_markdown_parser-2.4.3 → slack_markdown_parser-2.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slack-markdown-parser"
-version = "2.4.3"
+version = "2.4.4"
 description = "Convert LLM Markdown into Slack Block Kit messages"
 readme = "README.md"
 requires-python = ">=3.10"

{slack_markdown_parser-2.4.3 → slack_markdown_parser-2.4.4}/slack_markdown_parser/__init__.py

@@ -1,6 +1,6 @@
 """slack-markdown-parser public package API."""
 
-__version__ = "2.4.3"
+__version__ = "2.4.4"
 __license__ = "MIT"
 
 from .converter import (

{slack_markdown_parser-2.4.3 → slack_markdown_parser-2.4.4}/slack_markdown_parser/converter.py

@@ -84,6 +84,12 @@ LOOSE_TABLE_SEPARATOR_PATTERN = re.compile(
 TABLE_TOKEN_PATTERN = re.compile(
     r"\[(?P<markdown_label>[^\]\n]+)\]\((?P<markdown_url>https?://[^\s)]+)\)"
     r"|<(?P<angle_url>https?://[^>\s|]+)(?:\|(?P<angle_label>[^>\n]+))?>"
+    # Slack mention tokens: user (<@U…>/<@W…>), channel (<#C…>/<#G…>), user
+    # group (<!subteam^S…>), and broadcast (<!here>/<!channel>/<!everyone>).
+    # An optional ``|label`` is the human-readable display the author saw; the
+    # rich_text element is rendered by Slack from the id, so the label is dropped.
+    r"|<(?P<mention>@[UW][A-Z0-9]+|#[CG][A-Z0-9]+|!subteam\^[A-Z0-9]+"
+    r"|!(?:here|channel|everyone))(?:\|[^>\n]+)?>"
     r"|(?P<token>"
     r"(?P<code>(?P<code_delimiter>`+)(?P<code_text>[^\n]+?)(?P=code_delimiter))"
     r"|~~[^~]+~~"
@@ -1317,6 +1323,40 @@ def looks_like_markdown_table(text: str) -> bool:
     return table_like_lines >= 2
 
 
+def _slack_mention_element(mention: str) -> dict[str, Any]:
+    """Map a Slack mention token body to its rich_text element.
+
+    ``mention`` is the token interior without the angle brackets or ``|label``
+    (e.g. ``@U123``, ``#C123``, ``!subteam^S123``, ``!here``). Slack renders
+    these from the id alone, so no display text is carried.
+    """
+    sigil, body = mention[0], mention[1:]
+    if sigil == "@":
+        return {"type": "user", "user_id": body}
+    if sigil == "#":
+        return {"type": "channel", "channel_id": body}
+    if body.startswith("subteam^"):
+        return {"type": "usergroup", "usergroup_id": body[len("subteam^") :]}
+    return {"type": "broadcast", "range": body}
+
+
+def _slack_mention_element_to_token(element: dict[str, Any]) -> str:
+    """Inverse of :func:`_slack_mention_element` for plain-text fallbacks.
+
+    Emitting the canonical ``<#C…>`` / ``<@U…>`` token (rather than an empty
+    string) keeps the mention live when a rich_text block is downgraded to a
+    mrkdwn fallback, so it still links and notifies.
+    """
+    element_type = element.get("type")
+    if element_type == "user":
+        return f"<@{element.get('user_id', '')}>"
+    if element_type == "channel":
+        return f"<#{element.get('channel_id', '')}>"
+    if element_type == "usergroup":
+        return f"<!subteam^{element.get('usergroup_id', '')}>"
+    return f"<!{element.get('range', '')}>"
+
+
 def _create_rich_text_inline_elements(
     text: str, *, empty_text: str = ""
 ) -> list[dict[str, Any]]:
@@ -1340,6 +1380,7 @@ def _create_rich_text_inline_elements(
         markdown_url = match.group("markdown_url")
         angle_url = match.group("angle_url")
         angle_label = match.group("angle_label")
+        mention = match.group("mention")
         token = match.group("token") or ""
 
         if markdown_label and markdown_url:
@@ -1350,6 +1391,8 @@ def _create_rich_text_inline_elements(
                 "url": angle_url,
                 "text": angle_label or angle_url,
             }
+        elif mention:
+            element = _slack_mention_element(mention)
         else:
             style: dict[str, bool] = {}
             content = token
@@ -1368,9 +1411,26 @@ def _create_rich_text_inline_elements(
                 content = content[1:-1]
                 style["italic"] = True
 
-            element = {"type": "text", "text": content}
-            if style:
-                element["style"] = style
+            # A link wrapped entirely in emphasis (``**[text](url)**``) is matched
+            # by the emphasis branch above, not the link branch, so its inner
+            # content is a bare ``[text](url)``. Emit a styled ``link`` element
+            # rather than a literal text run, otherwise the link is dead in Slack.
+            inner_link = (
+                TABLE_TOKEN_PATTERN.fullmatch(content)
+                if style and not style.get("code")
+                else None
+            )
+            if inner_link is not None and inner_link.group("markdown_url"):
+                element = {
+                    "type": "link",
+                    "url": inner_link.group("markdown_url"),
+                    "text": inner_link.group("markdown_label"),
+                    "style": style,
+                }
+            else:
+                element = {"type": "text", "text": content}
+                if style:
+                    element["style"] = style
         elements.append(element)
         last_index = match.end()
 
@@ -1410,12 +1470,11 @@ def extract_plain_text_from_table_cell(cell: dict[str, Any]) -> str:
             if not isinstance(element, dict):
                 continue
             if element.get("type") == "rich_text_section":
-                for child in element.get("elements", []):
-                    if isinstance(child, dict):
-                        if child.get("type") == "link":
-                            texts.append(str(child.get("text") or child.get("url", "")))
-                        else:
-                            texts.append(child.get("text", ""))
+                texts.append(
+                    _rich_text_inline_elements_to_plain_text(
+                        element.get("elements", [])
+                    )
+                )
             elif "text" in element:
                 texts.append(str(element.get("text", "")))
         return "".join(texts)
@@ -1482,6 +1541,8 @@ def _rich_text_inline_elements_to_plain_text(elements: list[dict[str, Any]]) ->
         element_type = element.get("type")
         if element_type == "link":
             texts.append(str(element.get("text") or element.get("url", "")))
+        elif element_type in {"user", "channel", "usergroup", "broadcast"}:
+            texts.append(_slack_mention_element_to_token(element))
         else:
             texts.append(str(element.get("text", "")))
     return "".join(texts)
@@ -2017,44 +2078,73 @@ def convert_markdown_to_slack_payloads(
     return payloads
 
 
-def blocks_to_plain_text(blocks: list[dict[str, Any]]) -> str:
-    """Build plain text representation from Slack blocks."""
+def _markdown_block_to_plain_text(block: dict[str, Any]) -> str:
+    """Downgrade a ``markdown`` block, preferring the build-time annotation."""
+    text = getattr(block, "_plain_text", None) or ""
+    if text:
+        return str(text)
+    raw_text = block.get("text", "")
+    if not raw_text:
+        return ""
+    return _normalize_markdown_block_plain_text(
+        _strip_synthetic_blank_line_placeholders(
+            _strip_synthetic_spaces_from_plain_text(
+                strip_zero_width_spaces(raw_text),
+                getattr(block, "_synthetic_space_indices", None),
+            ),
+            getattr(block, "_synthetic_blank_line_indices", None),
+        )
+    )
+
+
+def _blocks_to_downgrade_parts(
+    blocks: list[dict[str, Any]], *, fallback: bool
+) -> list[str]:
+    """Shared block walker behind :func:`blocks_to_plain_text` and
+    :func:`build_fallback_text_from_blocks`.
+
+    The two public functions intentionally differ in a few policies, kept
+    explicit on the ``fallback`` flag: fallback keeps table cells verbatim
+    (empty cells preserve column alignment) and emits a whole table as one
+    part, while the plain-text view strips zero-width spaces, drops empty
+    cells, emits one part per row, and surfaces ``text`` from unknown blocks.
+    """
     parts: list[str] = []
 
     for block in blocks or []:
-        block_type = block.get("type") if isinstance(block, dict) else None
+        if not isinstance(block, dict):
+            continue
+        block_type = block.get("type")
 
         if block_type == "markdown":
-            text = getattr(block, "_plain_text", None) or ""
-            if not text:
-                raw_text = block.get("text", "")
-                if raw_text:
-                    text = _normalize_markdown_block_plain_text(
-                        _strip_synthetic_blank_line_placeholders(
-                            _strip_synthetic_spaces_from_plain_text(
-                                strip_zero_width_spaces(raw_text),
-                                getattr(block, "_synthetic_space_indices", None),
-                            ),
-                            getattr(block, "_synthetic_blank_line_indices", None),
-                        )
-                    )
-            if text:
+            text = _markdown_block_to_plain_text(block)
+            if text.strip() if fallback else text:
                 parts.append(text)
         elif block_type == "table":
-            rows = block.get("rows") or []
-            for row in rows:
-                cell_texts: list[str] = []
+            row_texts: list[str] = []
+            for row in block.get("rows") or []:
                 if not isinstance(row, list):
                     continue
-                for cell in row:
-                    cell_text = extract_plain_text_from_table_cell(cell)
-                    if cell_text:
-                        cell_texts.append(strip_zero_width_spaces(cell_text))
+                if fallback:
+                    cell_texts = [
+                        extract_plain_text_from_table_cell(cell) for cell in row
+                    ]
+                else:
+                    cell_texts = []
+                    for cell in row:
+                        cell_text = extract_plain_text_from_table_cell(cell)
+                        if cell_text:
+                            cell_texts.append(strip_zero_width_spaces(cell_text))
                 if cell_texts:
-                    parts.append(" | ".join(cell_texts))
+                    row_texts.append(" | ".join(cell_texts))
+            if fallback:
+                if row_texts:
+                    parts.append("\n".join(row_texts))
+            else:
+                parts.extend(row_texts)
         elif block_type == "rich_text":
             text = _rich_text_block_to_plain_text(block)
-            if text:
+            if text.strip() if fallback else text:
                 parts.append(text)
         elif block_type == "header":
             text = block.get("text", {})
@@ -2070,66 +2160,24 @@ def blocks_to_plain_text(blocks: list[dict[str, Any]]) -> str:
                 parts.append(image_text)
         elif block_type == "divider":
             parts.append(getattr(block, "_plain_text", None) or "---")
-        elif isinstance(block, dict):
+        elif not fallback:
             text = block.get("text", "")
             if text:
                 parts.append(str(text))
 
+    return parts
+
+
+def blocks_to_plain_text(blocks: list[dict[str, Any]]) -> str:
+    """Build plain text representation from Slack blocks."""
+    parts = _blocks_to_downgrade_parts(blocks, fallback=False)
     return "\n".join([p for p in parts if p]).strip()
 
 
 def build_fallback_text_from_blocks(blocks: list[dict[str, Any]]) -> str:
     """Build Slack fallback text from block structure."""
-    plain_parts: list[str] = []
-
-    for block in blocks or []:
-        if not isinstance(block, dict):
-            continue
-
-        if block.get("type") == "markdown":
-            text = getattr(block, "_plain_text", None) or ""
-            if not text:
-                text = _normalize_markdown_block_plain_text(
-                    _strip_synthetic_blank_line_placeholders(
-                        _strip_synthetic_spaces_from_plain_text(
-                            strip_zero_width_spaces(block.get("text", "")),
-                            getattr(block, "_synthetic_space_indices", None),
-                        ),
-                        getattr(block, "_synthetic_blank_line_indices", None),
-                    ),
-                )
-            if text.strip():
-                plain_parts.append(text)
-        elif block.get("type") == "table":
-            table_lines: list[str] = []
-            for row in block.get("rows", []):
-                if not isinstance(row, list):
-                    continue
-                cells = [extract_plain_text_from_table_cell(cell) for cell in row]
-                if cells:
-                    table_lines.append(" | ".join(cells))
-            if table_lines:
-                plain_parts.append("\n".join(table_lines))
-        elif block.get("type") == "rich_text":
-            text = _rich_text_block_to_plain_text(block)
-            if text.strip():
-                plain_parts.append(text)
-        elif block.get("type") == "header":
-            text = block.get("text", {})
-            if isinstance(text, dict) and text.get("text"):
-                plain_parts.append(str(text.get("text", "")))
-        elif block.get("type") == "image":
-            alt_text = str(block.get("alt_text", "")).strip()
-            image_url = str(block.get("image_url", "")).strip()
-            image_text = alt_text or image_url
-            if alt_text and image_url:
-                image_text = f"{alt_text} ({image_url})"
-            if image_text:
-                plain_parts.append(image_text)
-        elif block.get("type") == "divider":
-            plain_parts.append(getattr(block, "_plain_text", None) or "---")
-
-    return "\n\n".join([part for part in plain_parts if part.strip()])
+    parts = _blocks_to_downgrade_parts(blocks, fallback=True)
+    return "\n\n".join([part for part in parts if part.strip()])
 
 
 # Backward-compatible helper retained for existing imports.

{slack_markdown_parser-2.4.3 → slack_markdown_parser-2.4.4/slack_markdown_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-markdown-parser
-Version: 2.4.3
+Version: 2.4.4
 Summary: Convert LLM Markdown into Slack Block Kit messages
 Author: darkgaldragon
 License-Expression: MIT