slack-markdown-parser 2.3.2__tar.gz → 2.4.0__tar.gz

{slack_markdown_parser-2.3.2 → slack_markdown_parser-2.4.0}/CHANGELOG.md

@@ -6,6 +6,16 @@ The format is based on Keep a Changelog, and the project follows Semantic Versio
 
 ## [Unreleased]
 
+## [2.4.0] - 2026-05-14
+
+### Added
+
+- Added automatic richer Block Kit output for unambiguous standalone Markdown constructs, including image blocks, dividers, fenced code, simple quotes, and simple lists, while leaving Markdown headings in `markdown` blocks so Slack can preserve heading levels.
+
+### Documentation
+
+- Documented the Slack mobile `markdown` block limitation where list-item continuation lines are re-prefixed with the list marker, and linked the tracking issue so users can check upstream status instead of expecting a parser-side workaround.
+
 ## [2.3.2] - 2026-04-17
 
 ### Fixed

{slack_markdown_parser-2.3.2/slack_markdown_parser.egg-info → slack_markdown_parser-2.4.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: slack-markdown-parser
-Version: 2.3.2
-Summary: Convert LLM Markdown into Slack Block Kit markdown/table messages
+Version: 2.4.0
+Summary: Convert LLM Markdown into Slack Block Kit messages
 Author: darkgaldragon
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/darkgaldragon/slack-markdown-parser
@@ -30,7 +30,8 @@ Dynamic: license-file
 
 # slack-markdown-parser
 
-`slack-markdown-parser` is a Python library that converts ordinary Markdown generated by LLMs into Slack Block Kit messages built from `markdown` and `table` blocks.
+`slack-markdown-parser` is a Python library that converts general Markdown generated by LLMs into Slack Block Kit messages built from `markdown`, `table`, and selected richer blocks so the output renders cleanly in Slack.
+Basic headings and text formatting stay in `markdown` blocks, while constructs that benefit from dedicated Slack rendering, such as tables and simple standalone lists, are converted into native Block Kit blocks to produce a ChatGPT-like reading experience.
 
 ## Why this library exists
 
@@ -42,23 +43,25 @@ Many Slack AI bots have traditionally converted model output into Slack-specific
 
 ## Design approach
 
-This library uses Slack Block Kit `markdown` blocks for regular Markdown and `table` blocks for tables.
+This library combines Slack Block Kit's newer `markdown` block, `table` blocks, and richer block conversion for Markdown patterns that can be mapped safely.
 
 | Problem | Approach |
 |---|---|
-| Extra conversion work | Send ordinary Markdown through Slack `markdown` blocks without rewriting it into `mrkdwn`. |
-| Formatting instability | Prefer zero-width spaces (`U+200B`) around formatting markers, and only add visible spaces in a few language-specific cases where Slack still renders Japanese, Chinese, or Korean text incorrectly. |
-| No table syntax in `mrkdwn` | Detect Markdown tables and convert them into Slack `table` blocks, including repair of common LLM-generated table inconsistencies. |
+| Extra conversion work | Slack `markdown` blocks can render a useful subset of Markdown other than tables, so LLM output can usually be sent with minimal rewriting instead of being converted into `mrkdwn`. |
+| Formatting instability | Slack's `markdown` parser is not complete, so this library adds zero-width spaces (`U+200B`) around formatting-marker boundaries and uses visible spaces only for a few Japanese, Chinese, and Korean cases where that is still needed. This keeps emphasis stable across English and dense CJK text. |
+| No table syntax in `mrkdwn` | Detect Markdown tables and render them as Slack `table` blocks, while also repairing common LLM-generated table issues such as missing pipes. |
+| Rich LLM output | Convert standalone images, dividers, simple quotes, code fences, and simple lists into native Block Kit blocks where the Markdown structure is unambiguous. |
 
-The goal is natural rendering on Slack, not full CommonMark or HTML fidelity.
+The goal is natural rendering on Slack without exposing raw formatting markers, not full CommonMark or HTML fidelity.
 If Slack itself does not support a construct in `markdown` blocks, this library prefers safe plain-text rendering or explicit `table` blocks over aggressive rewrites into old `mrkdwn`.
 
 ## Features
 
-- Convert ordinary Markdown into Slack `markdown` blocks
+- Convert general Markdown into Slack `markdown` blocks
 - Convert Markdown tables into Slack `table` blocks
+- Promote safe standalone Markdown constructs into richer Block Kit blocks: `image`, `divider`, and `rich_text`
 - Repair common LLM table issues such as missing outer pipes, missing separator rows, mismatched column counts, and empty cells
-- Split output into multiple Slack messages when needed to satisfy Slack's "one table per message" constraint
+- Split output into multiple Slack messages when needed to satisfy Slack's "one table per message" and per-message block-count constraints
 - Remove ANSI/control characters and neutralize invalid Slack angle-bracket tokens before block generation
 - Add zero-width spaces around inline formatting markers to reduce rendering issues outside fenced code blocks, while preserving English-like punctuation-only boundaries that Slack already renders reliably
 - Add visible spaces for a small set of nested inline-code cases in dense Japanese, Chinese, and Korean text when zero-width spaces alone are not enough
@@ -73,7 +76,7 @@ The library is built around how Slack actually renders `markdown` and `table` bl
 
 Slack updated its [`markdown` block docs](https://docs.slack.dev/reference/block-kit/blocks/markdown-block/)
 and [changelog entry](https://docs.slack.dev/changelog/2026/03/06/block-kit-rich-text)
-on March 6, 2026 to describe broader support for headings, dividers, task lists,
+on March 6, 2026 as it started supporting broader Markdown features such as headings, dividers, task lists,
 native Markdown tables, and syntax-highlighted code blocks. In the Slack Web
 workspace used for this project's April 8, 2026 validation, raw `markdown`
 blocks rendered those constructs natively, including distinct heading levels
@@ -90,6 +93,7 @@ Reliable in current Slack rendering:
 - Bare URLs, `<https://...>` style links, Markdown links, reference-style links, and mailto links
 - Bullet lists, ordered lists, task lists, and simple blockquotes
 - Explicit Slack `table` blocks generated from Markdown tables
+- Explicit richer blocks generated from unambiguous Markdown, such as standalone images, code fences, simple lists, and simple quotes
 - In environments where Slack has enabled the newer renderer, raw Markdown headings, dividers, and tables inside `markdown` blocks
 
 Known Slack-side limitations:
@@ -100,19 +104,22 @@ Known Slack-side limitations:
 - Raw Markdown tables inside `markdown` blocks now render in some newer Slack environments, but explicit Slack `table` blocks remain the reliable option across workspaces and delivery paths
 - Markdown image syntax does not become an embedded image in `markdown` blocks
 - Math, raw HTML, HTML comments, `<details>`, admonition syntax, and Mermaid are rendered as plain text or code, not as rich features
+- Some newly documented Block Kit block types can be unavailable on a given `chat.postMessage` path; this library emits only a conservative subset of richer block types that has been validated through real Slack posting checks.
+- The Slack **mobile** app re-prefixes the list marker onto each continuation line of a list item inside `markdown` blocks (e.g. `1. Heading` followed by an indented paragraph shows as `1. Heading` / `1.continuation` on mobile, while Slack desktop and Slack Web render the same payload correctly). This is a Slack client-side rendering behavior, not a parser bug. Tracking: [issue #45](https://github.com/darkgaldragon/slack-markdown-parser/issues/45).
 
 What this library compensates for:
 
 - Normalizes underscore emphasis (`_..._`, `__...__`) into Slack-friendly asterisk emphasis
 - Wraps bare URLs into Slack-friendly `<https://...>` link form before sending `markdown` blocks
 - Repairs malformed LLM-generated tables before converting them into Slack `table` blocks
+- Converts unambiguous standalone Markdown constructs into native Block Kit blocks when that is safer than relying on raw `markdown` rendering
 - Keeps table-like rows inside fenced code blocks out of table normalization
 - Optionally turns internal blank lines into placeholder lines that keep paragraphs visibly separated in Slack `markdown` blocks
 - Neutralizes invalid Slack angle-bracket tokens such as raw HTML-like tags
 
 ## Requirements
 
-- Your Slack integration must support Block Kit payloads with `markdown` and `table` blocks.
+- Your Slack integration must support Block Kit payloads with `markdown`, `table`, and the richer blocks emitted by this library (`rich_text`, `image`, and `divider`).
 - This library does not help when your delivery path only accepts plain `text` or `mrkdwn` strings.
 
 ## Installation

{slack_markdown_parser-2.3.2 → slack_markdown_parser-2.4.0}/README-ja.md

@@ -1,6 +1,7 @@
 # slack-markdown-parser
 
-LLM が生成するふつうの Markdown を、Slack Block Kit（`markdown` + `table` ブロック）に変換する Python ライブラリです。
+LLM が生成する一般的な Markdown を、Slackで綺麗にレンダリングできるように、Slack Block Kit（`markdown` / `table` / 一部のリッチブロック）に変換する Python ライブラリです。
+基本的な見出しや文字修飾は `markdown` ブロックで対応し、さらにテーブルや単純な単独リストなど、Slack ネイティブの表示が有効な記法は専用の Block Kit ブロックに変換することで、ChatGPT のような読み心地に近づけています。
 
 ## 背景
 
@@ -12,23 +13,25 @@ Slack で AI BOT を動かすとき、従来は Slack 独自の `mrkdwn` 形式
 
 ## 設計方針
 
-Slack Block Kit の `markdown` ブロックと `table` ブロックを使って、上の課題に対応します。
+Slack Block Kit の比較的あたらしい `markdown` ブロック、`table` ブロック、そして安全に判定できる Markdown だけを対象にしたリッチブロック変換で、上の課題に対応できるようにしました。
 
 | 課題 | 解決手段 |
 |---|---|
-| 変換の手間 | `markdown` ブロックがふつうの Markdown を受け取れるので、LLM 出力を `mrkdwn` に書き換えずに使う |
-| 装飾の崩れ | 基本はゼロ幅スペース（`U+200B`）で装飾記号の境界を補い、それでも崩れる一部の日本語・中国語・韓国語のケースだけ可視スペースを使う |
-| テーブル非対応 | Markdown テーブルを見つけて `table` ブロックに変換し、LLM が作りがちな表の崩れも自動で補う |
+| 変換の手間 | `markdown` ブロックがテーブル以外のある程度の Markdown をレンダリングできるので、LLM 出力を `mrkdwn` に書き換えずになるべくそのまま使う |
+| 装飾の崩れ | `markdown` ブロックのMarkdownパーサーが完全ではないため、文字修飾が反映されない問題に対して、ゼロ幅スペース（`U+200B`）で装飾記号の境界を補い、それでも崩れる一部の日本語・中国語・韓国語のケースだけ可視スペースを使うことで、英語だけでなく、日本語、中国語、韓国語のレンダリングが崩れやすい言語についても、安定して装飾記号が反映される |
+| テーブル非対応 | Markdown テーブルを検知して `table` ブロックに変換してレンダリングすると同時に、LLM が起こしがちな表の崩れ（パイプ不足等）も自動で補う |
+| リッチなLLM出力 | 単独画像、水平線、単純な引用、コードフェンス、単純なリストを、意味が明確な範囲で Slack ネイティブの Block Kit ブロックへ変換する |
 
-このライブラリの目標は、CommonMark や HTML を完全再現することではなく、Slack 上で自然に読める表示を作ることです。
+このライブラリの目標は、CommonMark や HTML を完全再現することではなく、Slack 上で修飾記号を露出させず、自然に読める表示を作ることです。
 Slack の `markdown` ブロック自体が対応していない構文は、古い `mrkdwn` へ無理に書き換えるより、安全なプレーンテキスト表示や `table` ブロック化を優先します。
 
 ## 主な機能
 
-- ふつうの Markdown テキストを `markdown` ブロックに変換
+- 一般的な Markdown テキストを `markdown` ブロックに変換
 - Markdown テーブルを `table` ブロックに変換
+- 安全に判定できる単独 Markdown 構文を `image` / `divider` / `rich_text` ブロックに変換
 - LLM が生成する表で起こりやすい崩れ（外枠パイプ不足、区切り行不足、列数不一致、空セル）を補正
-- テーブルごとにメッセージを自動分割し、Slack の「1メッセージ1テーブル」制約に対応
+- 必要に応じてメッセージを自動分割し、Slack の「1メッセージ1テーブル」制約とメッセージあたりのブロック数制限に対応
 - ANSI escape / 制御文字を除去し、不正な Slack 角括弧トークンを無害化
 - フェンスドコードブロック外では、装飾記号の前後にゼロ幅スペースを入れて表示崩れを減らす
 - 日本語・中国語・韓国語の詰まった文で、インラインコードを含む装飾が崩れる一部のケースでは可視スペースを補って安定化
@@ -41,7 +44,7 @@ Slack の `markdown` ブロック自体が対応していない構文は、古
 
 本ライブラリは、Slack の `markdown` / `table` ブロックが実際にどう見えるかを前提に設計しています。
 
-Slack は 2026-03-06 に `markdown` ブロックの公式ドキュメントを更新し、見出し、水平線、タスクリスト、表、言語付きコードブロックなど、これまでより多くの Markdown 記法を案内し始めました。ただし、これらの機能は環境ごとに順番に有効化されるとも書かれています。つまり、ワークスペースやクライアントによって見え方が違う可能性があります。
+Slack は 2026-03-06 に `markdown` ブロックの公式ドキュメントを更新し、見出し、水平線、タスクリスト、表、言語付きコードブロックなど、これまでより多くの Markdown 記法をサポートし始めました。ただし、これらの機能は環境ごとに順番に有効化されるとも書かれています。つまり、ワークスペースやクライアントによって見え方が違う可能性があります。
 
 現在の Slack で比較的安定して表示されるもの:
 
@@ -49,6 +52,7 @@ Slack は 2026-03-06 に `markdown` ブロックの公式ドキュメントを
 - bare URL, `<https://...>` 形式リンク, Markdown リンク, 参照リンク, mailto リンク
 - 箇条書き, 番号付きリスト, タスクリスト, 単純な引用
 - Markdown テーブルを変換した明示的な Slack `table` ブロック
+- 単独画像、コードフェンス、単純なリスト、単純な引用から生成したリッチブロック
 - Slack 側で新しい Markdown 表示が有効な環境では、`markdown` ブロック内の見出し・水平線・表
 
 Slack 側の制約として残るもの:
@@ -59,19 +63,22 @@ Slack 側の制約として残るもの:
 - `markdown` ブロック内の生 Markdown テーブルは一部環境では表示されるが、安定性では明示的な Slack `table` ブロックの方が上
 - Markdown 画像記法は `markdown` ブロック内では埋め込み画像にならない
 - 数式, 生 HTML, HTML comment, `<details>`, admonition 記法, Mermaid は特別な表示にならず、テキストまたはコードとして出る
+- 新しく公式記載された Block Kit ブロックでも、利用する `chat.postMessage` 経路では未対応の場合があるため、このライブラリは実際の Slack 送信で確認した保守的なリッチブロックだけを出力する
+- Slack **モバイル**アプリは、`markdown` ブロック内のリスト項目に属する継続行（CommonMark で同じリスト項目に紐づくインデントされた段落）の先頭に、リストマーカーを再付加してしまう。例: `1. 見出し` の次にインデントされた継続段落を置くと、モバイルでは `1. 見出し` と `1.継続行...` のように番号が重複して表示される。Slack デスクトップ／Web は同じペイロードを正しく描画する。これはパーサー側の不具合ではなく Slack クライアントのレンダリング挙動。追跡: [issue #45](https://github.com/darkgaldragon/slack-markdown-parser/issues/45)。
 
 このライブラリが吸収するもの:
 
 - underscore 装飾 (`_..._`, `__...__`) を Slack 互換の asterisk 装飾へ正規化
 - bare URL を Slack の `<https://...>` 形式にそろえる
 - 崩れた Markdown テーブルを補って Slack `table` ブロックへ変換
+- 意味が明確な単独 Markdown 構文を、raw `markdown` 表示に頼らず Slack ネイティブの Block Kit ブロックへ変換
 - フェンスドコード内の table 風行をテーブル処理から除外
 - 必要に応じて、内部空行を補助用の行に置き換えて段落の区切りを見えやすくする
 - 生 HTML 風タグなど、Slack の特殊記法としては無効な `<...>` 形式を無害化
 
 ## 利用前提
 
-- Slack Block Kit の `blocks` で `markdown` / `table` ブロックを送信できる実装が必要です。
+- Slack Block Kit の `blocks` で `markdown` / `table` と、このライブラリが出力するリッチブロック（`rich_text`, `image`, `divider`）を送信できる実装が必要です。
 - `text` / `mrkdwn` のみ送信できる経路では利用できません。
 
 ## インストール

{slack_markdown_parser-2.3.2 → slack_markdown_parser-2.4.0}/README.md

@@ -1,6 +1,7 @@
 # slack-markdown-parser
 
-`slack-markdown-parser` is a Python library that converts ordinary Markdown generated by LLMs into Slack Block Kit messages built from `markdown` and `table` blocks.
+`slack-markdown-parser` is a Python library that converts general Markdown generated by LLMs into Slack Block Kit messages built from `markdown`, `table`, and selected richer blocks so the output renders cleanly in Slack.
+Basic headings and text formatting stay in `markdown` blocks, while constructs that benefit from dedicated Slack rendering, such as tables and simple standalone lists, are converted into native Block Kit blocks to produce a ChatGPT-like reading experience.
 
 ## Why this library exists
 
@@ -12,23 +13,25 @@ Many Slack AI bots have traditionally converted model output into Slack-specific
 
 ## Design approach
 
-This library uses Slack Block Kit `markdown` blocks for regular Markdown and `table` blocks for tables.
+This library combines Slack Block Kit's newer `markdown` block, `table` blocks, and richer block conversion for Markdown patterns that can be mapped safely.
 
 | Problem | Approach |
 |---|---|
-| Extra conversion work | Send ordinary Markdown through Slack `markdown` blocks without rewriting it into `mrkdwn`. |
-| Formatting instability | Prefer zero-width spaces (`U+200B`) around formatting markers, and only add visible spaces in a few language-specific cases where Slack still renders Japanese, Chinese, or Korean text incorrectly. |
-| No table syntax in `mrkdwn` | Detect Markdown tables and convert them into Slack `table` blocks, including repair of common LLM-generated table inconsistencies. |
+| Extra conversion work | Slack `markdown` blocks can render a useful subset of Markdown other than tables, so LLM output can usually be sent with minimal rewriting instead of being converted into `mrkdwn`. |
+| Formatting instability | Slack's `markdown` parser is not complete, so this library adds zero-width spaces (`U+200B`) around formatting-marker boundaries and uses visible spaces only for a few Japanese, Chinese, and Korean cases where that is still needed. This keeps emphasis stable across English and dense CJK text. |
+| No table syntax in `mrkdwn` | Detect Markdown tables and render them as Slack `table` blocks, while also repairing common LLM-generated table issues such as missing pipes. |
+| Rich LLM output | Convert standalone images, dividers, simple quotes, code fences, and simple lists into native Block Kit blocks where the Markdown structure is unambiguous. |
 
-The goal is natural rendering on Slack, not full CommonMark or HTML fidelity.
+The goal is natural rendering on Slack without exposing raw formatting markers, not full CommonMark or HTML fidelity.
 If Slack itself does not support a construct in `markdown` blocks, this library prefers safe plain-text rendering or explicit `table` blocks over aggressive rewrites into old `mrkdwn`.
 
 ## Features
 
-- Convert ordinary Markdown into Slack `markdown` blocks
+- Convert general Markdown into Slack `markdown` blocks
 - Convert Markdown tables into Slack `table` blocks
+- Promote safe standalone Markdown constructs into richer Block Kit blocks: `image`, `divider`, and `rich_text`
 - Repair common LLM table issues such as missing outer pipes, missing separator rows, mismatched column counts, and empty cells
-- Split output into multiple Slack messages when needed to satisfy Slack's "one table per message" constraint
+- Split output into multiple Slack messages when needed to satisfy Slack's "one table per message" and per-message block-count constraints
 - Remove ANSI/control characters and neutralize invalid Slack angle-bracket tokens before block generation
 - Add zero-width spaces around inline formatting markers to reduce rendering issues outside fenced code blocks, while preserving English-like punctuation-only boundaries that Slack already renders reliably
 - Add visible spaces for a small set of nested inline-code cases in dense Japanese, Chinese, and Korean text when zero-width spaces alone are not enough
@@ -43,7 +46,7 @@ The library is built around how Slack actually renders `markdown` and `table` bl
 
 Slack updated its [`markdown` block docs](https://docs.slack.dev/reference/block-kit/blocks/markdown-block/)
 and [changelog entry](https://docs.slack.dev/changelog/2026/03/06/block-kit-rich-text)
-on March 6, 2026 to describe broader support for headings, dividers, task lists,
+on March 6, 2026 as it started supporting broader Markdown features such as headings, dividers, task lists,
 native Markdown tables, and syntax-highlighted code blocks. In the Slack Web
 workspace used for this project's April 8, 2026 validation, raw `markdown`
 blocks rendered those constructs natively, including distinct heading levels
@@ -60,6 +63,7 @@ Reliable in current Slack rendering:
 - Bare URLs, `<https://...>` style links, Markdown links, reference-style links, and mailto links
 - Bullet lists, ordered lists, task lists, and simple blockquotes
 - Explicit Slack `table` blocks generated from Markdown tables
+- Explicit richer blocks generated from unambiguous Markdown, such as standalone images, code fences, simple lists, and simple quotes
 - In environments where Slack has enabled the newer renderer, raw Markdown headings, dividers, and tables inside `markdown` blocks
 
 Known Slack-side limitations:
@@ -70,19 +74,22 @@ Known Slack-side limitations:
 - Raw Markdown tables inside `markdown` blocks now render in some newer Slack environments, but explicit Slack `table` blocks remain the reliable option across workspaces and delivery paths
 - Markdown image syntax does not become an embedded image in `markdown` blocks
 - Math, raw HTML, HTML comments, `<details>`, admonition syntax, and Mermaid are rendered as plain text or code, not as rich features
+- Some newly documented Block Kit block types can be unavailable on a given `chat.postMessage` path; this library emits only a conservative subset of richer block types that has been validated through real Slack posting checks.
+- The Slack **mobile** app re-prefixes the list marker onto each continuation line of a list item inside `markdown` blocks (e.g. `1. Heading` followed by an indented paragraph shows as `1. Heading` / `1.continuation` on mobile, while Slack desktop and Slack Web render the same payload correctly). This is a Slack client-side rendering behavior, not a parser bug. Tracking: [issue #45](https://github.com/darkgaldragon/slack-markdown-parser/issues/45).
 
 What this library compensates for:
 
 - Normalizes underscore emphasis (`_..._`, `__...__`) into Slack-friendly asterisk emphasis
 - Wraps bare URLs into Slack-friendly `<https://...>` link form before sending `markdown` blocks
 - Repairs malformed LLM-generated tables before converting them into Slack `table` blocks
+- Converts unambiguous standalone Markdown constructs into native Block Kit blocks when that is safer than relying on raw `markdown` rendering
 - Keeps table-like rows inside fenced code blocks out of table normalization
 - Optionally turns internal blank lines into placeholder lines that keep paragraphs visibly separated in Slack `markdown` blocks
 - Neutralizes invalid Slack angle-bracket tokens such as raw HTML-like tags
 
 ## Requirements
 
-- Your Slack integration must support Block Kit payloads with `markdown` and `table` blocks.
+- Your Slack integration must support Block Kit payloads with `markdown`, `table`, and the richer blocks emitted by this library (`rich_text`, `image`, and `divider`).
 - This library does not help when your delivery path only accepts plain `text` or `mrkdwn` strings.
 
 ## Installation

{slack_markdown_parser-2.3.2 → slack_markdown_parser-2.4.0}/docs/spec-ja.md

@@ -9,13 +9,13 @@
 
 ## 出力
 
-- Slack Block Kit ブロック（`markdown` / `table`）
-- 複数テーブル入力時は「1メッセージ1テーブル」を満たすメッセージ群
+- Slack Block Kit ブロック（`markdown`, `table`, `rich_text`, `image`, `divider`）
+- 複数テーブルや多数の昇格ブロックがある入力時は、「1メッセージ1テーブル」と Slack のメッセージあたりブロック数制限を満たすメッセージ群
 
 ## 設計目標
 
 このパーサーは、CommonMark 全体や HTML / リッチドキュメントの完全再現を目標にはしません。
-目的は、Slack Block Kit の `markdown` / `table` ブロックで送ったときに自然に読めるメッセージを作ることです。
+目的は、Slack Block Kit で送ったときに自然に読めるメッセージを作ることです。
 
 Markdown としての厳密さより Slack 上での読みやすさが重要になる場合は、Slack 上で安定して読める表現を優先します。
 
@@ -31,10 +31,10 @@ Markdown としての厳密さより Slack 上での読みやすさが重要に
 6. テーブル領域と非テーブル領域に分割する
 7. 領域ごとにブロックを作る
    - テーブル領域: セル内装飾を解析して `table` ブロックを生成。変換に失敗した場合は `markdown` ブロックに戻す
-   - 非テーブル領域: 必要に応じてゼロ幅スペースを加えた上で `markdown` ブロックを生成する
-   - `preserve_visual_blank_lines=True` の場合は、非テーブル領域の内部空行を「ノーブレークスペースだけを含む行」に置き換えてから `markdown` ブロックを作る
+   - 非テーブル領域: 安全に判定できる単独 Markdown 構文を先にリッチブロックへ変換し、残りのテキストは必要に応じてゼロ幅スペースを加えた上で `markdown` ブロックを生成する
+   - `preserve_visual_blank_lines=True` の場合は、残った `markdown` ブロックの内部空行を「ノーブレークスペースだけを含む行」に置き換えてから `markdown` ブロックを作る
 
-`convert_markdown_to_slack_messages` は上記の結果を「1メッセージ1テーブル」制約に沿って分割します。
+`convert_markdown_to_slack_messages` は上記の結果を「1メッセージ1テーブル」制約と Slack のメッセージあたりブロック数制限に沿って分割します。
 `convert_markdown_to_slack_payloads` は、同じ分割結果に `chat.postMessage.text` 用のプレビュー文字列を付けた送信データを返します。
 
 ## 実測ベースの Slack の挙動
@@ -49,6 +49,7 @@ Markdown としての厳密さより Slack 上での読みやすさが重要に
 - bare URL, `<https://...>` 形式リンク, Markdown リンク, 参照リンク, mailto リンク
 - 箇条書き, 番号付きリスト, タスクリスト, 単純な1段引用
 - Slack `table` ブロック
+- 意味が明確な単独 Markdown 構文から生成した Slack ネイティブのリッチブロック
 
 Slack は 2026-03-06 に `markdown` ブロックの公式ドキュメントを更新し、これまでより多くの Markdown 記法を案内し始めました。本プロジェクトの 2026-04-08 の Slack Web 実測では、raw の `markdown` ブロックで次を確認しています。
 
@@ -73,6 +74,13 @@ Slack は 2026-03-06 に `markdown` ブロックの公式ドキュメントを
 - `_..._` / `__...__` を Slack 互換の `*...*` / `**...**` に正規化する
 - bare URL を Slack で安定しやすい `<https://...>` 形式にそろえる
 - 崩れた Markdown テーブルを補って `table` ブロックへ変換する
+- 意味が明確な単独 Markdown 構文を Slack ネイティブのブロックへ変換する
+  - 単独行の画像構文 `![alt](https://...)` → `image`
+  - 水平線 → `divider`
+  - フェンスドコード → `rich_text_preformatted`
+  - 単純な1段引用 → `rich_text_quote`
+  - 単純な箇条書き / 番号付きリスト → `rich_text_list`
+    - リストは、テキスト領域の先頭または空行の直後から始まり、連続する非空行がすべてリスト項目で、1〜3スペースの曖昧なネストインデントや Markdown バックスラッシュエスケープに依存せず、直後にインデント付きの継続段落がない場合だけ昇格する
 - フェンスドコード内の table 風行をテーブル解析対象から除外する
 - 内部空行を、必要に応じて段落区切りを見えやすくする補助行へ置き換える
 - `<foo>` や生 HTML 風タグのような、Slack の特殊記法としては無効な `<...>` 形式を無害化する

{slack_markdown_parser-2.3.2 → slack_markdown_parser-2.4.0}/docs/spec.md

@@ -9,13 +9,13 @@ This document describes how `slack-markdown-parser` converts Markdown into Slack
 
 ## Output
 
-- Slack Block Kit blocks (`markdown` / `table`)
-- When the input contains multiple tables, a list of messages that satisfies the "one table per message" rule
+- Slack Block Kit blocks (`markdown`, `table`, `rich_text`, `image`, and `divider`)
+- When the input contains multiple tables or many promoted blocks, a list of messages that satisfies the "one table per message" rule and Slack's per-message block-count limit
 
 ## Design target
 
 This parser does not try to reproduce full CommonMark, HTML, or rich-document rendering.
-Its goal is to produce Slack messages that read naturally when delivered through Slack Block Kit `markdown` and `table` blocks.
+Its goal is to produce Slack messages that read naturally when delivered through Slack Block Kit blocks.
 
 When exact Markdown fidelity conflicts with Slack readability, readable Slack output takes priority.
 
@@ -31,10 +31,10 @@ When exact Markdown fidelity conflicts with Slack readability, readable Slack ou
 6. Split the text into table regions and non-table regions
 7. Build blocks for each region:
    - Table regions: parse inline cell styling and generate a `table` block. If conversion fails, such as when there are fewer than two candidate lines or the parse result is empty, fall back to a `markdown` block.
-   - Non-table regions: add zero-width spaces where needed and generate a `markdown` block.
-   - If `preserve_visual_blank_lines=True`, replace internal blank lines in non-table regions with lines that contain only a non-breaking space before emitting the `markdown` block.
+   - Non-table regions: first promote safe standalone Markdown constructs into richer Block Kit blocks, then add zero-width spaces where needed and generate `markdown` blocks for the remaining text.
+   - If `preserve_visual_blank_lines=True`, replace internal blank lines in remaining `markdown` blocks with lines that contain only a non-breaking space before emitting the `markdown` block.
 
-`convert_markdown_to_slack_messages` then splits the resulting block list to satisfy the "one table per message" rule.
+`convert_markdown_to_slack_messages` then splits the resulting block list to satisfy the "one table per message" rule and Slack's per-message block-count limit.
 `convert_markdown_to_slack_payloads` returns the same split blocks plus preview `text` values ready for `chat.postMessage`.
 
 ## How Slack behaved in testing
@@ -49,6 +49,7 @@ The behaviors below are based on practical validation against real Slack clients
 - Bare URLs, `<https://...>` style links, Markdown links, reference-style links, and mailto links
 - Bullet lists, ordered lists, task lists, and simple one-level blockquotes
 - Slack `table` blocks
+- Native richer blocks generated from unambiguous standalone Markdown constructs
 
 Slack published updated `markdown` block documentation and a changelog entry on March 6, 2026. In the Slack Web workspace validated for this project on April 8, 2026, raw `markdown` blocks rendered:
 
@@ -73,6 +74,13 @@ Slack still controls when those newer features appear and how they look, so trea
 - `_..._` and `__...__` are normalized into Slack-friendly `*...*` and `**...**`
 - Bare URLs are wrapped into Slack-friendly `<https://...>` form before `markdown` block delivery
 - Malformed Markdown tables are repaired before `table` block generation
+- Unambiguous standalone Markdown constructs are promoted into native Slack blocks:
+  - standalone image syntax `![alt](https://...)` to `image`
+  - thematic-break lines to `divider`
+  - fenced code blocks to `rich_text_preformatted`
+  - 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.
 - 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.3.2 → slack_markdown_parser-2.4.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slack-markdown-parser"
-version = "2.3.2"
-description = "Convert LLM Markdown into Slack Block Kit markdown/table messages"
+version = "2.4.0"
+description = "Convert LLM Markdown into Slack Block Kit messages"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"

{slack_markdown_parser-2.3.2 → slack_markdown_parser-2.4.0}/slack_markdown_parser/__init__.py

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

{slack_markdown_parser-2.3.2 → slack_markdown_parser-2.4.0}/slack_markdown_parser/converter.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import html
 import re
 from typing import Any
+from urllib.parse import urlparse
 
 ZWSP = "\u200b"
 NBSP = "\u00a0"
@@ -24,6 +25,11 @@ CONTROL_CHAR_PATTERN = re.compile(r"[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]")
 SLACK_ANGLE_TOKEN_PATTERN = re.compile(r"<[^>\n]+>")
 BARE_URL_PATTERN = re.compile(r"https?://[^\s<]+", re.IGNORECASE)
 FENCE_OPEN_PATTERN = re.compile(r"^[ \t]{0,3}(`{3,}|~{3,})([^\n]*)$")
+STANDALONE_IMAGE_PATTERN = re.compile(
+    r"^[ \t]*!\[(?P<alt>[^\]\n]*)\]\((?P<url>https?://[^\s)]+)"
+    r"(?:[ \t]+(?P<title>\"[^\"\n]*\"|'[^'\n]*'))?[ \t]*\)[ \t]*$",
+    re.IGNORECASE,
+)
 MARKDOWN_LINK_PATTERN = re.compile(r"\[[^\]\n]+\]\([^\)\n]+\)")
 INLINE_CODE_SPAN_PATTERN = re.compile(r"(?<!`)`[^`\n]+`(?!`)", flags=re.DOTALL)
 EMPHASIS_PATTERNS = (
@@ -48,6 +54,8 @@ THEMATIC_BREAK_PATTERN = re.compile(
 LIST_ITEM_PATTERN = re.compile(
     r"^(?P<indent>[ \t]*)(?P<marker>\d+[.)]|[-+*])(?P<spacing>[ \t]+|$)"
 )
+TASK_LIST_MARKER_PATTERN = re.compile(r"^\[[ xX]\](?:[ \t]+|$)")
+MARKDOWN_BACKSLASH_ESCAPE_PATTERN = re.compile(r"\\[\\`*_{}\[\]()#+\-.!>|]")
 DOUBLE_UNDERSCORE_EMPHASIS_PATTERN = re.compile(
     r"(?<![\\0-9A-Za-z_])__(?=\S)(.+?\S)__(?![0-9A-Za-z_])"
 )
@@ -78,6 +86,7 @@ ALLOWED_SLACK_ANGLE_TOKEN_PATTERNS = (
     re.compile(r"^<!subteam\^[A-Z0-9]+(?:\|[^>\n]+)?>$"),
     re.compile(r"^<!date\^[^>\n]+>$"),
 )
+SLACK_MAX_BLOCKS_PER_MESSAGE = 50
 
 
 def decode_html_entities(text: str) -> str:
@@ -210,6 +219,31 @@ def _is_ordered_list_marker(marker: str) -> bool:
     return bool(marker) and marker[0].isdigit()
 
 
+def _ordered_list_marker_number(marker: str) -> int:
+    if not _is_ordered_list_marker(marker):
+        return 1
+    try:
+        return int(marker[:-1])
+    except ValueError:
+        return 1
+
+
+def _list_indent_level(indent: str) -> int:
+    width = _indent_width(indent or "")
+    if width <= 3:
+        return 0
+    return min(8, ((width - 4) // 4) + 1)
+
+
+def _is_ambiguous_rich_list_indent(indent: str) -> bool:
+    width = _indent_width(indent or "")
+    return 0 < width <= 3
+
+
+def _has_markdown_backslash_escape(text: str) -> bool:
+    return bool(MARKDOWN_BACKSLASH_ESCAPE_PATTERN.search(text or ""))
+
+
 def _is_thematic_break_line(line: str) -> bool:
     return bool(THEMATIC_BREAK_PATTERN.match(line))
 
@@ -1146,12 +1180,15 @@ def looks_like_markdown_table(text: str) -> bool:
     return table_like_lines >= 2
 
 
-def _create_table_cell(text: str) -> dict[str, Any]:
-    """Build Slack rich_text cell from markdown fragment."""
+def _create_rich_text_inline_elements(
+    text: str, *, empty_text: str = ""
+) -> list[dict[str, Any]]:
+    """Build Slack rich text inline elements from a small markdown fragment."""
     clean_text = strip_zero_width_spaces(text or "")
     clean_text = clean_text.replace("\\|", "|")
     if not clean_text.strip():
-        clean_text = "-"
+        clean_text = empty_text
+
     elements: list[dict[str, Any]] = []
     last_index = 0
 
@@ -1207,9 +1244,21 @@ def _create_table_cell(text: str) -> dict[str, Any]:
     if not elements:
         elements.append({"type": "text", "text": clean_text})
 
+    return elements
+
+
+def _create_rich_text_section(text: str, *, empty_text: str = "") -> dict[str, Any]:
+    return {
+        "type": "rich_text_section",
+        "elements": _create_rich_text_inline_elements(text, empty_text=empty_text),
+    }
+
+
+def _create_table_cell(text: str) -> dict[str, Any]:
+    """Build Slack rich_text cell from markdown fragment."""
     return {
         "type": "rich_text",
-        "elements": [{"type": "rich_text_section", "elements": elements}],
+        "elements": [_create_rich_text_section(text, empty_text="-")],
     }
 
 
@@ -1274,6 +1323,419 @@ def markdown_table_to_slack_table(table_markdown: str) -> dict[str, Any] | None:
 markdown_table_to_table_block = markdown_table_to_slack_table
 
 
+def _truncate_plain_text(text: str, max_length: int) -> str:
+    if len(text) <= max_length:
+        return text
+    return text[: max_length - 1].rstrip() + "…"
+
+
+def _is_http_url(url: str) -> bool:
+    try:
+        parsed = urlparse(url)
+    except ValueError:
+        return False
+    return parsed.scheme in {"http", "https"} and bool(parsed.netloc)
+
+
+def _rich_text_inline_elements_to_plain_text(elements: list[dict[str, Any]]) -> str:
+    texts: list[str] = []
+    for element in elements or []:
+        if not isinstance(element, dict):
+            continue
+        element_type = element.get("type")
+        if element_type == "link":
+            texts.append(str(element.get("text") or element.get("url", "")))
+        else:
+            texts.append(str(element.get("text", "")))
+    return "".join(texts)
+
+
+def _rich_text_object_to_plain_text(element: dict[str, Any]) -> str:
+    element_type = element.get("type")
+    if element_type == "rich_text_section":
+        return _rich_text_inline_elements_to_plain_text(element.get("elements", []))
+    if element_type in {"rich_text_preformatted", "rich_text_quote"}:
+        return _rich_text_inline_elements_to_plain_text(element.get("elements", []))
+    if element_type == "rich_text_list":
+        style = element.get("style")
+        indent = max(0, int(element.get("indent") or 0))
+        offset = max(0, int(element.get("offset") or 0))
+        prefix = "  " * indent
+        lines: list[str] = []
+        for idx, child in enumerate(element.get("elements", []), start=1):
+            if not isinstance(child, dict):
+                continue
+            child_text = _rich_text_object_to_plain_text(child).strip()
+            if not child_text:
+                continue
+            marker = f"{offset + idx}." if style == "ordered" else "-"
+            lines.append(f"{prefix}{marker} {child_text}")
+        return "\n".join(lines)
+    return ""
+
+
+def _rich_text_block_to_plain_text(block: dict[str, Any]) -> str:
+    annotated_plain_text = getattr(block, "_plain_text", None)
+    if annotated_plain_text:
+        return str(annotated_plain_text).strip()
+
+    parts = [
+        _rich_text_object_to_plain_text(element)
+        for element in block.get("elements", [])
+        if isinstance(element, dict)
+    ]
+    return "\n".join(part for part in parts if part).strip()
+
+
+def _plain_text_from_markdown_fragment(text: str) -> str:
+    return _rich_text_inline_elements_to_plain_text(
+        _create_rich_text_inline_elements(text)
+    ).strip()
+
+
+def _create_markdown_block(
+    content: str, *, preserve_visual_blank_lines: bool = False
+) -> dict[str, Any] | None:
+    formatted, synthetic_indices = _format_markdown_with_spacing_metadata(content)
+    plain_text = _build_markdown_block_plain_text(formatted, synthetic_indices)
+    synthetic_blank_line_indices: list[int] = []
+    if preserve_visual_blank_lines:
+        formatted, synthetic_blank_line_indices = (
+            _inject_visual_blank_line_placeholders(formatted)
+        )
+    if not formatted.strip():
+        return None
+
+    block = _AnnotatedSlackBlock({"type": "markdown", "text": formatted})
+    block._plain_text = plain_text
+    block._synthetic_space_indices = synthetic_indices
+    block._synthetic_blank_line_indices = synthetic_blank_line_indices
+    return block
+
+
+def _create_rich_text_block(
+    elements: list[dict[str, Any]], *, plain_text: str | None = None
+) -> dict[str, Any]:
+    block = _AnnotatedSlackBlock({"type": "rich_text", "elements": elements})
+    if plain_text is not None:
+        block._plain_text = plain_text
+    return block
+
+
+def _create_image_block_from_line(line: str) -> dict[str, Any] | None:
+    match = STANDALONE_IMAGE_PATTERN.match(line)
+    if not match:
+        return None
+
+    image_url = match.group("url").strip()
+    if not _is_http_url(image_url) or len(image_url) > 3000:
+        return None
+
+    alt_text = _plain_text_from_markdown_fragment(match.group("alt") or "")
+    alt_text = _truncate_plain_text(alt_text or "Image", 2000)
+    return {"type": "image", "image_url": image_url, "alt_text": alt_text}
+
+
+def _is_setext_heading_underline(lines: list[str], index: int) -> bool:
+    if index <= 0:
+        return False
+    line = lines[index].strip()
+    if not line or set(line) != {"-"}:
+        return False
+    return bool(lines[index - 1].strip())
+
+
+def _create_divider_block_from_line(
+    lines: list[str], index: int
+) -> dict[str, Any] | None:
+    if not _is_thematic_break_line(lines[index]):
+        return None
+    if _is_setext_heading_underline(lines, index):
+        return None
+    block = _AnnotatedSlackBlock({"type": "divider"})
+    block._plain_text = lines[index].strip()
+    return block
+
+
+def _strip_quote_marker(line: str) -> str | None:
+    match = re.match(r"^[ \t]{0,3}>[ \t]?(?P<text>.*)$", line)
+    if not match:
+        return None
+    return match.group("text")
+
+
+def _quote_lines_are_simple(lines: list[str]) -> bool:
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            return False
+        if stripped.startswith(">"):
+            return False
+        if LIST_ITEM_PATTERN.match(stripped):
+            return False
+        if _match_fence_open(stripped):
+            return False
+        if _has_markdown_backslash_escape(stripped):
+            return False
+    return True
+
+
+def _consume_quote_block(
+    lines: list[str], start: int
+) -> tuple[dict[str, Any], int] | None:
+    if _strip_quote_marker(lines[start]) is None:
+        return None
+
+    quote_lines: list[str] = []
+    cursor = start
+    while cursor < len(lines):
+        stripped = _strip_quote_marker(lines[cursor])
+        if stripped is None:
+            break
+        quote_lines.append(stripped)
+        cursor += 1
+
+    if not _quote_lines_are_simple(quote_lines):
+        return None
+
+    quote_text = "\n".join(quote_lines).strip()
+    if not quote_text:
+        return None
+
+    block = _create_rich_text_block(
+        [
+            {
+                "type": "rich_text_quote",
+                "elements": _create_rich_text_inline_elements(quote_text),
+            }
+        ],
+        plain_text="\n".join(lines[start:cursor]),
+    )
+    return block, cursor
+
+
+def _parse_simple_list_item(line: str) -> dict[str, Any] | None:
+    if _is_thematic_break_line(line):
+        return None
+
+    match = LIST_ITEM_PATTERN.match(line)
+    if not match:
+        return None
+
+    text = line[match.end() :].rstrip()
+    if TASK_LIST_MARKER_PATTERN.match(text):
+        return None
+
+    indent = match.group("indent") or ""
+    if _is_ambiguous_rich_list_indent(indent):
+        return None
+    if _has_markdown_backslash_escape(text):
+        return None
+
+    marker = match.group("marker")
+    return {
+        "style": "ordered" if _is_ordered_list_marker(marker) else "bullet",
+        "number": _ordered_list_marker_number(marker),
+        "indent": _list_indent_level(indent),
+        "text": text.strip() or " ",
+    }
+
+
+def _consume_list_block(
+    lines: list[str], start: int
+) -> tuple[dict[str, Any], int] | None:
+    first_entry = _parse_simple_list_item(lines[start])
+    if first_entry is None:
+        return None
+
+    first_match = LIST_ITEM_PATTERN.match(lines[start])
+    first_indent = _indent_width(first_match.group("indent") if first_match else "")
+    if first_indent > 3:
+        return None
+
+    if start > 0 and lines[start - 1].strip():
+        return None
+
+    entries: list[dict[str, Any]] = []
+    cursor = start
+    while cursor < len(lines) and lines[cursor].strip():
+        entry = _parse_simple_list_item(lines[cursor])
+        if entry is None:
+            return None
+        entries.append(entry)
+        cursor += 1
+
+    if not entries:
+        return None
+
+    lookahead = cursor
+    while lookahead < len(lines) and not lines[lookahead].strip():
+        lookahead += 1
+    if lookahead < len(lines):
+        next_line = lines[lookahead]
+        if _indent_width(next_line) > 0 and _parse_simple_list_item(next_line) is None:
+            return None
+
+    rich_elements: list[dict[str, Any]] = []
+    current_group: dict[str, Any] | None = None
+
+    def flush_group() -> None:
+        nonlocal current_group
+        if current_group:
+            rich_elements.append(current_group)
+        current_group = None
+
+    for entry in entries:
+        group_key = (entry["style"], entry["indent"])
+        if current_group is None or current_group["_key"] != group_key:
+            flush_group()
+            current_group = {
+                "type": "rich_text_list",
+                "style": entry["style"],
+                "indent": entry["indent"],
+                "elements": [],
+                "_key": group_key,
+            }
+            if entry["style"] == "ordered" and entry["number"] > 1:
+                current_group["offset"] = entry["number"] - 1
+
+        current_group["elements"].append(_create_rich_text_section(entry["text"]))
+
+    flush_group()
+    for element in rich_elements:
+        element.pop("_key", None)
+
+    return (
+        _create_rich_text_block(
+            rich_elements,
+            plain_text="\n".join(lines[start:cursor]),
+        ),
+        cursor,
+    )
+
+
+def _find_fence_close_index(
+    lines: list[str], start: int, fence: tuple[str, int]
+) -> int | None:
+    cursor = start + 1
+    while cursor < len(lines):
+        if _is_fence_close(lines[cursor], fence):
+            return cursor
+        cursor += 1
+    return None
+
+
+def _consume_fenced_code_block(
+    lines: list[str], start: int
+) -> tuple[dict[str, Any], int] | None:
+    open_match = FENCE_OPEN_PATTERN.match(lines[start])
+    if not open_match:
+        return None
+
+    fence = _match_fence_open(lines[start])
+    if fence is None:
+        return None
+
+    close_index = _find_fence_close_index(lines, start, fence)
+    if close_index is None:
+        return None
+
+    info = (open_match.group(2) or "").strip()
+    language = info.split()[0] if info else ""
+    code_text = "\n".join(lines[start + 1 : close_index])
+    preformatted: dict[str, Any] = {
+        "type": "rich_text_preformatted",
+        "elements": [{"type": "text", "text": code_text}],
+    }
+    if language and re.match(r"^[A-Za-z0-9_+.#-]+$", language):
+        preformatted["language"] = language
+    return (
+        _create_rich_text_block(
+            [preformatted],
+            plain_text="\n".join(lines[start : close_index + 1]),
+        ),
+        close_index + 1,
+    )
+
+
+def _consume_rich_markdown_block(
+    lines: list[str], index: int
+) -> tuple[dict[str, Any], int] | None:
+    if not lines[index].strip():
+        return None
+
+    consumers = (
+        lambda: _consume_fenced_code_block(lines, index),
+        lambda: (
+            (block, index + 1)
+            if (block := _create_image_block_from_line(lines[index]))
+            else None
+        ),
+        lambda: (
+            (block, index + 1)
+            if (block := _create_divider_block_from_line(lines, index))
+            else None
+        ),
+        lambda: _consume_quote_block(lines, index),
+        lambda: _consume_list_block(lines, index),
+    )
+
+    for consumer in consumers:
+        consumed = consumer()
+        if consumed:
+            return consumed
+    return None
+
+
+def _convert_markdown_text_segment_to_blocks(
+    content: str, *, preserve_visual_blank_lines: bool = False
+) -> list[dict[str, Any]]:
+    blocks: list[dict[str, Any]] = []
+    markdown_buffer: list[str] = []
+    lines = content.splitlines()
+    cursor = 0
+
+    def flush_markdown_buffer() -> None:
+        nonlocal markdown_buffer
+        if not markdown_buffer:
+            return
+        while markdown_buffer and not markdown_buffer[0].strip():
+            markdown_buffer.pop(0)
+        while markdown_buffer and not markdown_buffer[-1].strip():
+            markdown_buffer.pop()
+        if not markdown_buffer:
+            return
+        markdown_block = _create_markdown_block(
+            "\n".join(markdown_buffer),
+            preserve_visual_blank_lines=preserve_visual_blank_lines,
+        )
+        if markdown_block:
+            blocks.append(markdown_block)
+        markdown_buffer = []
+
+    while cursor < len(lines):
+        fence = _match_fence_open(lines[cursor])
+        if fence is not None and _find_fence_close_index(lines, cursor, fence) is None:
+            markdown_buffer.extend(lines[cursor:])
+            cursor = len(lines)
+            break
+
+        consumed = _consume_rich_markdown_block(lines, cursor)
+        if consumed:
+            flush_markdown_buffer()
+            block, cursor = consumed
+            blocks.append(block)
+            while cursor < len(lines) and not lines[cursor].strip():
+                cursor += 1
+            continue
+
+        markdown_buffer.append(lines[cursor])
+        cursor += 1
+
+    flush_markdown_buffer()
+    return blocks
+
+
 def split_markdown_into_segments(markdown_text: str) -> list[dict[str, str]]:
     """Split markdown into alternating text/table segments."""
     segments: list[dict[str, str]] = []
@@ -1352,19 +1814,12 @@ def convert_markdown_to_slack_blocks(
                 blocks.append(table_block)
                 continue
 
-        formatted, synthetic_indices = _format_markdown_with_spacing_metadata(content)
-        plain_text = _build_markdown_block_plain_text(formatted, synthetic_indices)
-        synthetic_blank_line_indices: list[int] = []
-        if preserve_visual_blank_lines:
-            formatted, synthetic_blank_line_indices = (
-                _inject_visual_blank_line_placeholders(formatted)
+        blocks.extend(
+            _convert_markdown_text_segment_to_blocks(
+                content,
+                preserve_visual_blank_lines=preserve_visual_blank_lines,
             )
-        if formatted.strip():
-            block = _AnnotatedSlackBlock({"type": "markdown", "text": formatted})
-            block._plain_text = plain_text
-            block._synthetic_space_indices = synthetic_indices
-            block._synthetic_blank_line_indices = synthetic_blank_line_indices
-            blocks.append(block)
+        )
 
     return blocks
 
@@ -1374,7 +1829,7 @@ convert_markdown_text_to_blocks = convert_markdown_to_slack_blocks
 
 
 def split_blocks_by_table(blocks: list[dict[str, Any]]) -> list[list[dict[str, Any]]]:
-    """Split blocks into multiple messages to satisfy one-table-per-message constraint."""
+    """Split blocks to satisfy Slack table and per-message block constraints."""
     messages: list[list[dict[str, Any]]] = []
     current_message: list[dict[str, Any]] = []
 
@@ -1385,6 +1840,9 @@ def split_blocks_by_table(blocks: list[dict[str, Any]]) -> list[list[dict[str, A
             messages.append([block])
             current_message = []
         else:
+            if len(current_message) >= SLACK_MAX_BLOCKS_PER_MESSAGE:
+                messages.append(current_message)
+                current_message = []
             current_message.append(block)
 
     if current_message:
@@ -1457,6 +1915,24 @@ def blocks_to_plain_text(blocks: list[dict[str, Any]]) -> str:
                         cell_texts.append(strip_zero_width_spaces(cell_text))
                 if cell_texts:
                     parts.append(" | ".join(cell_texts))
+        elif block_type == "rich_text":
+            text = _rich_text_block_to_plain_text(block)
+            if text:
+                parts.append(text)
+        elif block_type == "header":
+            text = block.get("text", {})
+            if isinstance(text, dict) and text.get("text"):
+                parts.append(str(text.get("text", "")))
+        elif block_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:
+                parts.append(image_text)
+        elif block_type == "divider":
+            parts.append(getattr(block, "_plain_text", None) or "---")
         elif isinstance(block, dict):
             text = block.get("text", "")
             if text:
@@ -1497,6 +1973,24 @@ def build_fallback_text_from_blocks(blocks: list[dict[str, Any]]) -> str:
                     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()])
 

{slack_markdown_parser-2.3.2 → slack_markdown_parser-2.4.0/slack_markdown_parser.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: slack-markdown-parser
-Version: 2.3.2
-Summary: Convert LLM Markdown into Slack Block Kit markdown/table messages
+Version: 2.4.0
+Summary: Convert LLM Markdown into Slack Block Kit messages
 Author: darkgaldragon
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/darkgaldragon/slack-markdown-parser
@@ -30,7 +30,8 @@ Dynamic: license-file
 
 # slack-markdown-parser
 
-`slack-markdown-parser` is a Python library that converts ordinary Markdown generated by LLMs into Slack Block Kit messages built from `markdown` and `table` blocks.
+`slack-markdown-parser` is a Python library that converts general Markdown generated by LLMs into Slack Block Kit messages built from `markdown`, `table`, and selected richer blocks so the output renders cleanly in Slack.
+Basic headings and text formatting stay in `markdown` blocks, while constructs that benefit from dedicated Slack rendering, such as tables and simple standalone lists, are converted into native Block Kit blocks to produce a ChatGPT-like reading experience.
 
 ## Why this library exists
 
@@ -42,23 +43,25 @@ Many Slack AI bots have traditionally converted model output into Slack-specific
 
 ## Design approach
 
-This library uses Slack Block Kit `markdown` blocks for regular Markdown and `table` blocks for tables.
+This library combines Slack Block Kit's newer `markdown` block, `table` blocks, and richer block conversion for Markdown patterns that can be mapped safely.
 
 | Problem | Approach |
 |---|---|
-| Extra conversion work | Send ordinary Markdown through Slack `markdown` blocks without rewriting it into `mrkdwn`. |
-| Formatting instability | Prefer zero-width spaces (`U+200B`) around formatting markers, and only add visible spaces in a few language-specific cases where Slack still renders Japanese, Chinese, or Korean text incorrectly. |
-| No table syntax in `mrkdwn` | Detect Markdown tables and convert them into Slack `table` blocks, including repair of common LLM-generated table inconsistencies. |
+| Extra conversion work | Slack `markdown` blocks can render a useful subset of Markdown other than tables, so LLM output can usually be sent with minimal rewriting instead of being converted into `mrkdwn`. |
+| Formatting instability | Slack's `markdown` parser is not complete, so this library adds zero-width spaces (`U+200B`) around formatting-marker boundaries and uses visible spaces only for a few Japanese, Chinese, and Korean cases where that is still needed. This keeps emphasis stable across English and dense CJK text. |
+| No table syntax in `mrkdwn` | Detect Markdown tables and render them as Slack `table` blocks, while also repairing common LLM-generated table issues such as missing pipes. |
+| Rich LLM output | Convert standalone images, dividers, simple quotes, code fences, and simple lists into native Block Kit blocks where the Markdown structure is unambiguous. |
 
-The goal is natural rendering on Slack, not full CommonMark or HTML fidelity.
+The goal is natural rendering on Slack without exposing raw formatting markers, not full CommonMark or HTML fidelity.
 If Slack itself does not support a construct in `markdown` blocks, this library prefers safe plain-text rendering or explicit `table` blocks over aggressive rewrites into old `mrkdwn`.
 
 ## Features
 
-- Convert ordinary Markdown into Slack `markdown` blocks
+- Convert general Markdown into Slack `markdown` blocks
 - Convert Markdown tables into Slack `table` blocks
+- Promote safe standalone Markdown constructs into richer Block Kit blocks: `image`, `divider`, and `rich_text`
 - Repair common LLM table issues such as missing outer pipes, missing separator rows, mismatched column counts, and empty cells
-- Split output into multiple Slack messages when needed to satisfy Slack's "one table per message" constraint
+- Split output into multiple Slack messages when needed to satisfy Slack's "one table per message" and per-message block-count constraints
 - Remove ANSI/control characters and neutralize invalid Slack angle-bracket tokens before block generation
 - Add zero-width spaces around inline formatting markers to reduce rendering issues outside fenced code blocks, while preserving English-like punctuation-only boundaries that Slack already renders reliably
 - Add visible spaces for a small set of nested inline-code cases in dense Japanese, Chinese, and Korean text when zero-width spaces alone are not enough
@@ -73,7 +76,7 @@ The library is built around how Slack actually renders `markdown` and `table` bl
 
 Slack updated its [`markdown` block docs](https://docs.slack.dev/reference/block-kit/blocks/markdown-block/)
 and [changelog entry](https://docs.slack.dev/changelog/2026/03/06/block-kit-rich-text)
-on March 6, 2026 to describe broader support for headings, dividers, task lists,
+on March 6, 2026 as it started supporting broader Markdown features such as headings, dividers, task lists,
 native Markdown tables, and syntax-highlighted code blocks. In the Slack Web
 workspace used for this project's April 8, 2026 validation, raw `markdown`
 blocks rendered those constructs natively, including distinct heading levels
@@ -90,6 +93,7 @@ Reliable in current Slack rendering:
 - Bare URLs, `<https://...>` style links, Markdown links, reference-style links, and mailto links
 - Bullet lists, ordered lists, task lists, and simple blockquotes
 - Explicit Slack `table` blocks generated from Markdown tables
+- Explicit richer blocks generated from unambiguous Markdown, such as standalone images, code fences, simple lists, and simple quotes
 - In environments where Slack has enabled the newer renderer, raw Markdown headings, dividers, and tables inside `markdown` blocks
 
 Known Slack-side limitations:
@@ -100,19 +104,22 @@ Known Slack-side limitations:
 - Raw Markdown tables inside `markdown` blocks now render in some newer Slack environments, but explicit Slack `table` blocks remain the reliable option across workspaces and delivery paths
 - Markdown image syntax does not become an embedded image in `markdown` blocks
 - Math, raw HTML, HTML comments, `<details>`, admonition syntax, and Mermaid are rendered as plain text or code, not as rich features
+- Some newly documented Block Kit block types can be unavailable on a given `chat.postMessage` path; this library emits only a conservative subset of richer block types that has been validated through real Slack posting checks.
+- The Slack **mobile** app re-prefixes the list marker onto each continuation line of a list item inside `markdown` blocks (e.g. `1. Heading` followed by an indented paragraph shows as `1. Heading` / `1.continuation` on mobile, while Slack desktop and Slack Web render the same payload correctly). This is a Slack client-side rendering behavior, not a parser bug. Tracking: [issue #45](https://github.com/darkgaldragon/slack-markdown-parser/issues/45).
 
 What this library compensates for:
 
 - Normalizes underscore emphasis (`_..._`, `__...__`) into Slack-friendly asterisk emphasis
 - Wraps bare URLs into Slack-friendly `<https://...>` link form before sending `markdown` blocks
 - Repairs malformed LLM-generated tables before converting them into Slack `table` blocks
+- Converts unambiguous standalone Markdown constructs into native Block Kit blocks when that is safer than relying on raw `markdown` rendering
 - Keeps table-like rows inside fenced code blocks out of table normalization
 - Optionally turns internal blank lines into placeholder lines that keep paragraphs visibly separated in Slack `markdown` blocks
 - Neutralizes invalid Slack angle-bracket tokens such as raw HTML-like tags
 
 ## Requirements
 
-- Your Slack integration must support Block Kit payloads with `markdown` and `table` blocks.
+- Your Slack integration must support Block Kit payloads with `markdown`, `table`, and the richer blocks emitted by this library (`rich_text`, `image`, and `divider`).
 - This library does not help when your delivery path only accepts plain `text` or `mrkdwn` strings.
 
 ## Installation