confpub-cli 1.4.4__tar.gz → 1.5.0__tar.gz

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confpub-cli
-Version: 1.4.4
+Version: 1.5.0
 Summary: Agent-first CLI to publish Markdown to Confluence
 Project-URL: Homepage, https://github.com/ThomasRohde/confpub-cli
 Project-URL: Repository, https://github.com/ThomasRohde/confpub-cli.git
@@ -118,7 +118,7 @@ confpub plan apply --plan confpub-plan.json --dry-run
 
 - **Structured JSON output** — every command returns the same envelope shape on stdout
 - **Transactional workflow** — plan → validate → apply → verify with fingerprint-based conflict detection
-- **Markdown → Confluence** — code blocks become code macros, `> [!NOTE]` becomes Info panels, tables stay tables
+- **Markdown → Confluence** — code blocks become code macros, `> [!NOTE]` becomes Info panels, tables stay tables, task lists, math, definition lists, footnotes, panels, expand/collapse, and page layouts
 - **Asset handling** — images are uploaded as attachments and URLs are rewritten automatically
 - **Idempotent** — a lockfile tracks page IDs so re-publishing updates in place
 - **Agent-ready** — `confpub guide` returns the full CLI schema; `LLM=true` suppresses interactive behavior
@@ -344,6 +344,15 @@ confpub converts Markdown to Confluence Storage Format (and back via `page pull`
 | `![img](photo.png)` | Upload attachment + `<ac:image>` reference |
 | Tables | Standard XHTML `<table>` |
 | `~~strikethrough~~` | `<del>strikethrough</del>` |
+| `- [ ] task` / `- [x] done` | `<ac:task-list>` with task status |
+| `$E=mc^2$` | LaTeX math macro (inline) |
+| `$$...$$` | LaTeX math macro (block) |
+| `Term` + `: Definition` | `<dl><dt><dd>` definition list |
+| `[^1]` footnotes | Superscript links + numbered list |
+| `::: panel Title` | Confluence Panel macro |
+| `::: expand Title` | Confluence Expand macro |
+| `:::: layout two-equal` | Confluence page layout |
+| `---yaml---` front matter | Silently stripped |
 
 ---
 

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/README.md

@@ -77,7 +77,7 @@ confpub plan apply --plan confpub-plan.json --dry-run
 
 - **Structured JSON output** — every command returns the same envelope shape on stdout
 - **Transactional workflow** — plan → validate → apply → verify with fingerprint-based conflict detection
-- **Markdown → Confluence** — code blocks become code macros, `> [!NOTE]` becomes Info panels, tables stay tables
+- **Markdown → Confluence** — code blocks become code macros, `> [!NOTE]` becomes Info panels, tables stay tables, task lists, math, definition lists, footnotes, panels, expand/collapse, and page layouts
 - **Asset handling** — images are uploaded as attachments and URLs are rewritten automatically
 - **Idempotent** — a lockfile tracks page IDs so re-publishing updates in place
 - **Agent-ready** — `confpub guide` returns the full CLI schema; `LLM=true` suppresses interactive behavior
@@ -303,6 +303,15 @@ confpub converts Markdown to Confluence Storage Format (and back via `page pull`
 | `![img](photo.png)` | Upload attachment + `<ac:image>` reference |
 | Tables | Standard XHTML `<table>` |
 | `~~strikethrough~~` | `<del>strikethrough</del>` |
+| `- [ ] task` / `- [x] done` | `<ac:task-list>` with task status |
+| `$E=mc^2$` | LaTeX math macro (inline) |
+| `$$...$$` | LaTeX math macro (block) |
+| `Term` + `: Definition` | `<dl><dt><dd>` definition list |
+| `[^1]` footnotes | Superscript links + numbered list |
+| `::: panel Title` | Confluence Panel macro |
+| `::: expand Title` | Confluence Expand macro |
+| `:::: layout two-equal` | Confluence page layout |
+| `---yaml---` front matter | Silently stripped |
 
 ---
 

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/confpub/__init__.py

@@ -1,3 +1,3 @@
 """confpub — Agent-first CLI to publish Markdown to Confluence."""
 
-__version__ = "1.4.4"
+__version__ = "1.5.0"

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/confpub/converter.py

@@ -15,6 +15,12 @@ from typing import Any
 
 from markdown_it import MarkdownIt
 from markdown_it.token import Token
+from mdit_py_plugins.tasklists import tasklists_plugin
+from mdit_py_plugins.dollarmath import dollarmath_plugin
+from mdit_py_plugins.deflist import deflist_plugin
+from mdit_py_plugins.footnote import footnote_plugin
+from mdit_py_plugins.front_matter import front_matter_plugin
+from mdit_py_plugins.container import container_plugin
 
 # Admonition types mapping: GitHub [!TYPE] → Confluence macro name
 ADMONITION_MAP: dict[str, str] = {
@@ -34,12 +40,16 @@ class ConfluenceRenderer:
 
     def __init__(self) -> None:
         self._output: list[str] = []
-        self._list_stack: list[str] = []  # track nested ol/ul
+        self._list_stack: list[str] = []  # track nested ol/ul ("ol", "ul", "task-list")
+        self._task_id: int = 0  # incrementing counter for Confluence task IDs
+        self._footnote_refs: dict[int, int] = {}  # meta.id → display number
 
     def render(self, tokens: list[Token], options: dict[str, Any], env: dict[str, Any]) -> str:
         """Render a list of tokens to Confluence Storage Format."""
         self._output = []
         self._list_stack = []
+        self._task_id = 0
+        self._footnote_refs = {}
         i = 0
         while i < len(tokens):
             token = tokens[i]
@@ -71,10 +81,14 @@ class ConfluenceRenderer:
         return idx + 1
 
     def _render_paragraph_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        if self._list_stack and self._list_stack[-1] == "task-list":
+            return idx + 1  # suppress <p> inside task-body
         self._output.append("<p>")
         return idx + 1
 
     def _render_paragraph_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        if self._list_stack and self._list_stack[-1] == "task-list":
+            return idx + 1  # suppress </p> inside task-body
         self._output.append("</p>")
         return idx + 1
 
@@ -94,6 +108,10 @@ class ConfluenceRenderer:
             # Fallback for unknown inline types
             if token.type == "text":
                 self._output.append(escape(token.content))
+            elif token.type == "math_inline":
+                self._inline_math_inline(token)
+            elif token.type == "footnote_ref":
+                self._inline_footnote_ref(token)
 
     # ------------------------------------------------------------------
     # Inline tokens
@@ -253,24 +271,60 @@ class ConfluenceRenderer:
         return idx + 1
 
     def _render_bullet_list_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
-        self._output.append("<ul>")
-        self._list_stack.append("ul")
+        token = tokens[idx]
+        attrs = token.attrs or {}
+        if isinstance(attrs, dict) and attrs.get("class") == "contains-task-list":
+            self._output.append("<ac:task-list>")
+            self._list_stack.append("task-list")
+        else:
+            self._output.append("<ul>")
+            self._list_stack.append("ul")
         return idx + 1
 
     def _render_bullet_list_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
-        self._output.append("</ul>")
+        if self._list_stack and self._list_stack[-1] == "task-list":
+            self._output.append("</ac:task-list>")
+        else:
+            self._output.append("</ul>")
         if self._list_stack:
             self._list_stack.pop()
         return idx + 1
 
     def _render_list_item_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
-        self._output.append("<li>")
+        token = tokens[idx]
+        attrs = token.attrs or {}
+        if isinstance(attrs, dict) and attrs.get("class") == "task-list-item":
+            self._task_id += 1
+            checked = self._is_task_checked(tokens, idx)
+            status = "complete" if checked else "incomplete"
+            self._output.append("<ac:task>")
+            self._output.append(f"<ac:task-id>{self._task_id}</ac:task-id>")
+            self._output.append(f"<ac:task-status>{status}</ac:task-status>")
+            self._output.append("<ac:task-body>")
+        else:
+            self._output.append("<li>")
         return idx + 1
 
     def _render_list_item_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
-        self._output.append("</li>")
+        if self._list_stack and self._list_stack[-1] == "task-list":
+            self._output.append("</ac:task-body></ac:task>")
+        else:
+            self._output.append("</li>")
         return idx + 1
 
+    @staticmethod
+    def _is_task_checked(tokens: list[Token], list_item_idx: int) -> bool:
+        """Look ahead from list_item_open to find the checkbox html_inline and check state."""
+        for i in range(list_item_idx + 1, min(list_item_idx + 10, len(tokens))):
+            tok = tokens[i]
+            if tok.type == "list_item_close":
+                break
+            if tok.type == "inline" and tok.children:
+                for child in tok.children:
+                    if child.type == "html_inline" and "checkbox" in (child.content or ""):
+                        return 'checked="checked"' in child.content or "checked" in child.content.split()
+        return False
+
     # ------------------------------------------------------------------
     # Tables
     # ------------------------------------------------------------------
@@ -340,14 +394,186 @@ class ConfluenceRenderer:
         return idx + 1
 
     def _inline_html_inline(self, token: Token) -> None:
+        # Suppress task-list checkboxes (already handled by _render_list_item_open)
+        if "task-list-item-checkbox" in (token.content or ""):
+            return
         self._output.append(token.content)
 
+    # ------------------------------------------------------------------
+    # Dollar math (inline and block)
+    # ------------------------------------------------------------------
+
+    def _inline_math_inline(self, token: Token) -> None:
+        latex = token.content
+        self._output.append(
+            '<ac:structured-macro ac:name="mathinline">'
+            f"<ac:plain-text-body><![CDATA[{latex}]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+        )
+
+    def _render_math_block(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        latex = tokens[idx].content
+        self._output.append(
+            '<ac:structured-macro ac:name="mathblock">'
+            f"<ac:plain-text-body><![CDATA[{latex}]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+        )
+        return idx + 1
+
+    # ------------------------------------------------------------------
+    # Definition lists
+    # ------------------------------------------------------------------
+
+    def _render_dl_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("<dl>")
+        return idx + 1
+
+    def _render_dl_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</dl>")
+        return idx + 1
+
+    def _render_dt_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("<dt>")
+        return idx + 1
+
+    def _render_dt_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</dt>")
+        return idx + 1
+
+    def _render_dd_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("<dd>")
+        return idx + 1
+
+    def _render_dd_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</dd>")
+        return idx + 1
+
+    # ------------------------------------------------------------------
+    # Footnotes
+    # ------------------------------------------------------------------
+
+    def _inline_footnote_ref(self, token: Token) -> None:
+        meta_id = token.meta.get("id", 0) if token.meta else 0
+        # Display number is 1-based
+        display_num = meta_id + 1
+        self._footnote_refs[meta_id] = display_num
+        self._output.append(
+            f'<sup><a id="footnote-ref-{display_num}" href="#footnote-{display_num}">'
+            f"[{display_num}]</a></sup>"
+        )
+
+    def _render_footnote_block_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("<hr /><ol>")
+        return idx + 1
+
+    def _render_footnote_block_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</ol>")
+        return idx + 1
+
+    def _render_footnote_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        meta_id = tokens[idx].meta.get("id", 0) if tokens[idx].meta else 0
+        display_num = meta_id + 1
+        self._output.append(f'<li id="footnote-{display_num}">')
+        return idx + 1
+
+    def _render_footnote_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</li>")
+        return idx + 1
+
+    def _render_footnote_anchor(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        meta_id = tokens[idx].meta.get("id", 0) if tokens[idx].meta else 0
+        display_num = meta_id + 1
+        self._output.append(
+            f' <a href="#footnote-ref-{display_num}">\u21a9</a>'
+        )
+        return idx + 1
+
+    # ------------------------------------------------------------------
+    # Front matter (silently stripped)
+    # ------------------------------------------------------------------
+
+    def _render_front_matter(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        return idx + 1  # no output
+
+    # ------------------------------------------------------------------
+    # Container: panel
+    # ------------------------------------------------------------------
+
+    def _render_container_panel_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        info = tokens[idx].info.strip() if tokens[idx].info else ""
+        # info is e.g. "panel My Title" — strip the container name prefix
+        title = info[len("panel"):].strip() if info.startswith("panel") else info
+        self._output.append('<ac:structured-macro ac:name="panel">')
+        if title:
+            self._output.append(f'<ac:parameter ac:name="title">{escape(title)}</ac:parameter>')
+        self._output.append("<ac:rich-text-body>")
+        return idx + 1
+
+    def _render_container_panel_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</ac:rich-text-body></ac:structured-macro>")
+        return idx + 1
+
+    # ------------------------------------------------------------------
+    # Container: expand
+    # ------------------------------------------------------------------
+
+    def _render_container_expand_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        info = tokens[idx].info.strip() if tokens[idx].info else ""
+        title = info[len("expand"):].strip() if info.startswith("expand") else info
+        self._output.append('<ac:structured-macro ac:name="expand">')
+        if title:
+            self._output.append(f'<ac:parameter ac:name="title">{escape(title)}</ac:parameter>')
+        self._output.append("<ac:rich-text-body>")
+        return idx + 1
+
+    def _render_container_expand_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</ac:rich-text-body></ac:structured-macro>")
+        return idx + 1
+
+    # ------------------------------------------------------------------
+    # Container: layout
+    # ------------------------------------------------------------------
+
+    def _render_container_layout_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        info = tokens[idx].info.strip() if tokens[idx].info else ""
+        layout_type = info[len("layout"):].strip() if info.startswith("layout") else info
+        # Convert hyphens to underscores for Confluence ac:type
+        layout_type = layout_type.replace("-", "_") if layout_type else "single"
+        self._output.append(f'<ac:layout><ac:layout-section ac:type="{escape(layout_type)}">')
+        return idx + 1
+
+    def _render_container_layout_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</ac:layout-section></ac:layout>")
+        return idx + 1
+
+    # ------------------------------------------------------------------
+    # Container: cell
+    # ------------------------------------------------------------------
+
+    def _render_container_cell_open(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("<ac:layout-cell>")
+        return idx + 1
+
+    def _render_container_cell_close(self, tokens: list[Token], idx: int, _o: Any, _e: Any) -> int:
+        self._output.append("</ac:layout-cell>")
+        return idx + 1
+
 
 def _create_parser() -> MarkdownIt:
     """Create a configured markdown-it-py parser."""
     md = MarkdownIt("commonmark", {"html": True})
     md.enable("table")
     md.enable("strikethrough")
+    # mdit-py-plugins
+    tasklists_plugin(md)
+    dollarmath_plugin(md)
+    deflist_plugin(md)
+    footnote_plugin(md)
+    front_matter_plugin(md)
+    container_plugin(md, name="panel")
+    container_plugin(md, name="expand")
+    container_plugin(md, name="layout")
+    container_plugin(md, name="cell")
     return md
 
 

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/confpub/guide.py

@@ -382,6 +382,38 @@ def build_guide() -> dict[str, Any]:
                 ),
             ],
         },
+        "markdown_support": {
+            "description": "Markdown features converted to native Confluence Storage Format.",
+            "base": "CommonMark with GitHub-flavored extensions",
+            "features": {
+                "headings":       "# h1 through ###### h6 → <h1>–<h6>",
+                "bold_italic":    "**bold**, *italic* → <strong>, <em>",
+                "strikethrough":  "~~text~~ → <del>",
+                "inline_code":    "`code` → <code>",
+                "code_blocks":    "```lang ... ``` → ac:structured-macro code with language param",
+                "links":          "[text](url) → <a href>",
+                "images":         "![alt](path) → ac:image (local files uploaded as attachments)",
+                "tables":         "GFM tables → <table>",
+                "lists":          "Ordered and unordered, nested → <ol>, <ul>",
+                "blockquotes":    "> text → <blockquote>",
+                "admonitions":    "> [!NOTE|TIP|WARNING|CAUTION|IMPORTANT] → info/tip/warning/note macros",
+                "task_lists":     "- [ ] / - [x] → ac:task-list with ac:task elements",
+                "math_inline":    "$LaTeX$ → ac:structured-macro mathinline",
+                "math_block":     "$$...$$ → ac:structured-macro mathblock",
+                "definition_lists": "Term\\n: Definition → <dl><dt><dd>",
+                "footnotes":      "[^1] + [^1]: text → superscript links with numbered list",
+                "front_matter":   "---\\nyaml\\n--- → silently stripped",
+                "panels":         "::: panel Title\\ncontent\\n::: → ac:structured-macro panel",
+                "expand":         "::: expand Title\\ncontent\\n::: → ac:structured-macro expand",
+                "layouts":        ":::: layout two-equal\\n::: cell\\n...\\n::::\\n → ac:layout with ac:layout-section",
+            },
+            "layout_types": ["single", "two-equal", "two-left-sidebar", "two-right-sidebar", "three-equal", "three-with-sidebars"],
+            "agent_hint": (
+                "All features are always-on — the parser simply ignores syntax that isn't used. "
+                "Math macros require the Confluence LaTeX Math plugin to be installed on the server. "
+                "Layouts use :::: (4 colons) for the outer layout block and ::: (3 colons) for inner cells."
+            ),
+        },
         "assertions": {
             "description": "Post-condition assertions verified by plan.verify.",
             "file_format": "JSON array of assertion objects, or embedded in confpub.yaml under the 'assertions' key.",

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/confpub/reverse_converter.py

@@ -43,17 +43,46 @@ class ConfluenceMarkdownConverter(MarkdownConverter):
         kwargs.setdefault("heading_style", "ATX")
         kwargs.setdefault("bullets", "-")
         kwargs.setdefault("code_language", "")
-        kwargs.setdefault("strip", ["span"])
+        # Don't strip spans — we use <span> for inline macros like mathinline.
+        # Regular spans are handled in convert_span by returning raw text.
         super().__init__(**kwargs)
 
+    # ------------------------------------------------------------------
+    # Definition list support
+    # ------------------------------------------------------------------
+
+    def convert_dl(self, el: Tag, text: str, parent_tags: set | None = None) -> str:
+        return "\n\n" + text.strip() + "\n\n"
+
+    def convert_dt(self, el: Tag, text: str, parent_tags: set | None = None) -> str:
+        return text.strip() + "\n"
+
+    def convert_dd(self, el: Tag, text: str, parent_tags: set | None = None) -> str:
+        return ": " + text.strip() + "\n"
+
     # ------------------------------------------------------------------
     # Confluence macro handlers (dispatched via data-confluence-macro attr)
     # ------------------------------------------------------------------
 
+    def convert_span(self, el: Tag, text: str, parent_tags: set | None = None) -> str:
+        macro_name = el.get("data-confluence-macro")
+        if macro_name:
+            return self._convert_macro(el, text, str(macro_name))
+        return text
+
     def convert_div(self, el: Tag, text: str, parent_tags: set | None = None) -> str:
         macro_name = el.get("data-confluence-macro")
         if macro_name:
             return self._convert_macro(el, text, str(macro_name))
+        # Layout containers (from _preprocess_storage_format)
+        layout_macro = el.get("data-layout-macro")
+        if layout_macro == "layout":
+            layout_type = el.get("data-layout-type", "single")
+            inner = text.strip()
+            return f"\n\n:::: layout {layout_type}\n{inner}\n::::\n\n"
+        if layout_macro == "cell":
+            inner = text.strip()
+            return f"\n::: cell\n{inner}\n:::\n"
         return text
 
     def _convert_macro(self, el: Tag, text: str, macro_name: str) -> str:
@@ -61,6 +90,14 @@ class ConfluenceMarkdownConverter(MarkdownConverter):
             return self._convert_code_macro(el)
         if macro_name in REVERSE_ADMONITION_MAP:
             return self._convert_admonition_macro(el, text, macro_name)
+        if macro_name == "mathinline":
+            return self._convert_mathinline_macro(el)
+        if macro_name == "mathblock":
+            return self._convert_mathblock_macro(el)
+        if macro_name == "panel":
+            return self._convert_panel_macro(el)
+        if macro_name == "expand":
+            return self._convert_expand_macro(el)
         # Unknown macro
         self._unknown_macros.append(macro_name)
         self._warnings.append(f"Unknown macro '{macro_name}' converted to HTML comment")
@@ -68,6 +105,46 @@ class ConfluenceMarkdownConverter(MarkdownConverter):
         param_str = f" params={params}" if params else ""
         return f"\n\n<!-- confluence-macro: {macro_name}{param_str} -->\n\n"
 
+    def _convert_mathinline_macro(self, el: Tag) -> str:
+        code_el = el.find("pre", class_="confluence-code-body")
+        latex = code_el.get_text() if code_el else el.get_text()
+        return f"${latex}$"
+
+    def _convert_mathblock_macro(self, el: Tag) -> str:
+        code_el = el.find("pre", class_="confluence-code-body")
+        latex = code_el.get_text() if code_el else el.get_text()
+        return f"\n\n$$\n{latex}\n$$\n\n"
+
+    def _convert_panel_macro(self, el: Tag) -> str:
+        params = el.get("data-macro-params", "") or ""
+        title = ""
+        for part in str(params).split("; "):
+            if part.startswith("title="):
+                title = part[len("title="):]
+                break
+        body_el = el.find("div", class_="confluence-rich-text-body")
+        if body_el:
+            body_text = self.convert(str(body_el)).strip()
+        else:
+            body_text = el.get_text().strip()
+        header = f"panel {title}" if title else "panel"
+        return f"\n\n::: {header}\n{body_text}\n:::\n\n"
+
+    def _convert_expand_macro(self, el: Tag) -> str:
+        params = el.get("data-macro-params", "") or ""
+        title = ""
+        for part in str(params).split("; "):
+            if part.startswith("title="):
+                title = part[len("title="):]
+                break
+        body_el = el.find("div", class_="confluence-rich-text-body")
+        if body_el:
+            body_text = self.convert(str(body_el)).strip()
+        else:
+            body_text = el.get_text().strip()
+        header = f"expand {title}" if title else "expand"
+        return f"\n\n::: {header}\n{body_text}\n:::\n\n"
+
     def _convert_code_macro(self, el: Tag) -> str:
         language = el.get("data-macro-language", "") or ""
         # The code content is in the pre-processed plain text
@@ -139,10 +216,15 @@ def _preprocess_storage_format(html: str) -> tuple[BeautifulSoup, list[str]]:
     warnings: list[str] = []
     soup = BeautifulSoup(html, "html.parser")
 
-    # 1. Transform ac:structured-macro → div[data-confluence-macro]
+    # Inline macro names that should become <span> not <div> to preserve
+    # surrounding whitespace when markdownify processes them.
+    _INLINE_MACROS = {"mathinline"}
+
+    # 1. Transform ac:structured-macro → div/span[data-confluence-macro]
     for macro in soup.find_all("ac:structured-macro"):
         macro_name = macro.get("ac:name", "unknown")
-        div = soup.new_tag("div")
+        tag_name = "span" if macro_name in _INLINE_MACROS else "div"
+        div = soup.new_tag(tag_name)
         div["data-confluence-macro"] = macro_name
 
         # Extract parameters
@@ -199,7 +281,84 @@ def _preprocess_storage_format(html: str) -> tuple[BeautifulSoup, list[str]]:
 
         img_macro.replace_with(img)
 
-    # 3. Transform ac:link → a
+    # 3. Transform ac:task-list → ul with checkbox text
+    for task_list in soup.find_all("ac:task-list"):
+        ul = soup.new_tag("ul")
+        for task in task_list.find_all("ac:task", recursive=False):
+            li = soup.new_tag("li")
+            status_el = task.find("ac:task-status")
+            status = status_el.get_text().strip() if status_el else "incomplete"
+            checkbox = "[x] " if status == "complete" else "[ ] "
+            body_el = task.find("ac:task-body")
+            body_text = body_el.get_text().strip() if body_el else ""
+            li.string = checkbox + body_text
+            ul.append(li)
+        task_list.replace_with(ul)
+
+    # 4. Transform footnote markup
+    # Footnote refs: <sup><a href="#footnote-N">[N]</a></sup>
+    for sup in soup.find_all("sup"):
+        a_tag = sup.find("a")
+        if a_tag and a_tag.get("href", "").startswith("#footnote-"):
+            text = a_tag.get_text()
+            # e.g. "[1]" → "[^1]"
+            if text.startswith("[") and text.endswith("]"):
+                num = text[1:-1]
+                sup.replace_with(f"[^{num}]")
+
+    # Footnote definitions: detect by id="footnote-N" OR by back-link pattern
+    # (Confluence strips id attrs, so we fall back to detecting back-links)
+    _footnote_back_re = re.compile(r"#footnote-ref-(\d+)")
+    footnote_lis_found = False
+    for li in soup.find_all("li"):
+        li_id = li.get("id", "")
+        num = None
+        if li_id.startswith("footnote-"):
+            num = li_id[len("footnote-"):]
+        else:
+            # Fallback: detect by back-link <a href="#footnote-ref-N">
+            for back_a in li.find_all("a"):
+                m = _footnote_back_re.search(back_a.get("href", ""))
+                if m:
+                    num = m.group(1)
+                    break
+        if num:
+            footnote_lis_found = True
+            # Remove back-links
+            for back_a in li.find_all("a"):
+                if _footnote_back_re.search(back_a.get("href", "")):
+                    back_a.decompose()
+            text = li.get_text().strip()
+            p = soup.new_tag("p")
+            p.string = f"[^{num}]: {text}"
+            li.replace_with(p)
+
+    # Remove <hr> before footnote <ol> (the separator)
+    if footnote_lis_found:
+        for hr in soup.find_all("hr"):
+            next_sib = hr.find_next_sibling()
+            if next_sib and next_sib.name == "ol":
+                hr.decompose()
+
+    # 5. Transform ac:layout → div[data-layout-macro]
+    for layout in soup.find_all("ac:layout"):
+        layout_div = soup.new_tag("div")
+        layout_div["data-layout-macro"] = "layout"
+        section = layout.find("ac:layout-section")
+        if section:
+            layout_type = section.get("ac:type", "single")
+            # Convert underscores back to hyphens
+            layout_type = layout_type.replace("_", "-")
+            layout_div["data-layout-type"] = layout_type
+            for cell in section.find_all("ac:layout-cell", recursive=False):
+                cell_div = soup.new_tag("div")
+                cell_div["data-layout-macro"] = "cell"
+                for child in list(cell.children):
+                    cell_div.append(child.extract())
+                layout_div.append(cell_div)
+        layout.replace_with(layout_div)
+
+    # 6. Transform ac:link → a
     for link in soup.find_all("ac:link"):
         a = soup.new_tag("a")
 

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/tests/test_converter.py

@@ -248,3 +248,174 @@ class TestExtractH1Title:
     def test_h2_before_h1(self):
         md = "## Intro\n\n# Main Title"
         assert extract_h1_title(md) == "Main Title"
+
+
+class TestTaskLists:
+    def test_unchecked_task(self):
+        result = convert_markdown("- [ ] Buy milk")
+        assert "<ac:task-list>" in result
+        assert "<ac:task>" in result
+        assert "<ac:task-status>incomplete</ac:task-status>" in result
+        assert "Buy milk" in result
+        assert "</ac:task-body></ac:task>" in result
+        assert "</ac:task-list>" in result
+
+    def test_checked_task(self):
+        result = convert_markdown("- [x] Buy milk")
+        assert "<ac:task-status>complete</ac:task-status>" in result
+
+    def test_mixed_task_list(self):
+        md = "- [ ] First\n- [x] Second\n- [ ] Third"
+        result = convert_markdown(md)
+        assert result.count("<ac:task>") == 3
+        assert "<ac:task-status>incomplete</ac:task-status>" in result
+        assert "<ac:task-status>complete</ac:task-status>" in result
+
+    def test_task_ids_increment(self):
+        md = "- [ ] A\n- [ ] B\n- [ ] C"
+        result = convert_markdown(md)
+        assert "<ac:task-id>1</ac:task-id>" in result
+        assert "<ac:task-id>2</ac:task-id>" in result
+        assert "<ac:task-id>3</ac:task-id>" in result
+
+    def test_regular_list_unchanged(self):
+        result = convert_markdown("- Normal item\n- Another item")
+        assert "<ul>" in result
+        assert "<li>" in result
+        assert "<ac:task" not in result
+
+    def test_no_input_checkbox_in_output(self):
+        result = convert_markdown("- [ ] Task")
+        assert "<input" not in result
+
+
+class TestMath:
+    def test_inline_math(self):
+        result = convert_markdown("The equation $E=mc^2$ is famous.")
+        assert '<ac:structured-macro ac:name="mathinline">' in result
+        assert "<![CDATA[E=mc^2]]>" in result
+        assert "</ac:structured-macro>" in result
+
+    def test_block_math(self):
+        result = convert_markdown("$$\nx^2 + y^2 = z^2\n$$")
+        assert '<ac:structured-macro ac:name="mathblock">' in result
+        assert "x^2 + y^2 = z^2" in result
+
+    def test_inline_math_in_paragraph(self):
+        result = convert_markdown("Given $a$ and $b$, compute $a+b$.")
+        assert result.count('ac:name="mathinline"') == 3
+
+
+class TestDefinitionLists:
+    def test_basic_deflist(self):
+        md = "Term\n:   Definition here"
+        result = convert_markdown(md)
+        assert "<dl>" in result
+        assert "<dt>" in result
+        assert "Term" in result
+        assert "<dd>" in result
+        assert "Definition here" in result
+        assert "</dl>" in result
+
+    def test_multiple_terms(self):
+        md = "Apple\n:   A fruit\n\nBanana\n:   Another fruit"
+        result = convert_markdown(md)
+        assert result.count("<dt>") == 2
+        assert result.count("<dd>") == 2
+
+    def test_multiple_definitions(self):
+        md = "Term\n:   First def\n:   Second def"
+        result = convert_markdown(md)
+        assert result.count("<dd>") == 2
+
+
+class TestFootnotes:
+    def test_footnote_ref_link(self):
+        md = "Text with a footnote[^1].\n\n[^1]: Footnote content."
+        result = convert_markdown(md)
+        assert '<sup><a id="footnote-ref-1" href="#footnote-1">[1]</a></sup>' in result
+
+    def test_footnote_body(self):
+        md = "Text[^1].\n\n[^1]: Footnote content."
+        result = convert_markdown(md)
+        assert '<li id="footnote-1">' in result
+        assert "Footnote content." in result
+
+    def test_footnote_back_link(self):
+        md = "Text[^1].\n\n[^1]: Footnote content."
+        result = convert_markdown(md)
+        assert 'href="#footnote-ref-1"' in result
+        assert "\u21a9" in result
+
+    def test_multiple_footnotes(self):
+        md = "First[^1] and second[^2].\n\n[^1]: Note one.\n[^2]: Note two."
+        result = convert_markdown(md)
+        assert "footnote-1" in result
+        assert "footnote-2" in result
+        assert result.count("<ac:task") == 0  # no task contamination
+
+
+class TestFrontMatter:
+    def test_front_matter_stripped(self):
+        md = "---\ntitle: My Page\ntags: [a, b]\n---\n\n# Hello"
+        result = convert_markdown(md)
+        assert "title:" not in result
+        assert "tags:" not in result
+        assert "<h1>" in result
+        assert "Hello" in result
+
+    def test_no_regression_without_front_matter(self):
+        result = convert_markdown("# Hello\n\nWorld")
+        assert "<h1>" in result
+        assert "Hello" in result
+        assert "World" in result
+
+
+class TestContainerPanel:
+    def test_panel_with_title(self):
+        md = "::: panel Important Note\nThis is panel content.\n:::"
+        result = convert_markdown(md)
+        assert '<ac:structured-macro ac:name="panel">' in result
+        assert '<ac:parameter ac:name="title">Important Note</ac:parameter>' in result
+        assert "<ac:rich-text-body>" in result
+        assert "This is panel content." in result
+        assert "</ac:rich-text-body></ac:structured-macro>" in result
+
+    def test_panel_without_title(self):
+        md = "::: panel\nJust content.\n:::"
+        result = convert_markdown(md)
+        assert '<ac:structured-macro ac:name="panel">' in result
+        assert 'ac:name="title"' not in result
+        assert "Just content." in result
+
+
+class TestContainerExpand:
+    def test_expand_with_title(self):
+        md = "::: expand Click to expand\nHidden content here.\n:::"
+        result = convert_markdown(md)
+        assert '<ac:structured-macro ac:name="expand">' in result
+        assert '<ac:parameter ac:name="title">Click to expand</ac:parameter>' in result
+        assert "Hidden content here." in result
+
+
+class TestContainerLayout:
+    def test_two_equal_layout(self):
+        md = ":::: layout two-equal\n::: cell\nLeft column\n:::\n::: cell\nRight column\n:::\n::::"
+        result = convert_markdown(md)
+        assert '<ac:layout><ac:layout-section ac:type="two_equal">' in result
+        assert "<ac:layout-cell>" in result
+        assert "Left column" in result
+        assert "Right column" in result
+        assert "</ac:layout-cell>" in result
+        assert "</ac:layout-section></ac:layout>" in result
+
+    def test_single_column_layout(self):
+        md = ":::: layout single\n::: cell\nOnly column\n:::\n::::"
+        result = convert_markdown(md)
+        assert 'ac:type="single"' in result
+
+    def test_three_column_layout(self):
+        md = ":::: layout three-equal\n::: cell\nA\n:::\n::: cell\nB\n:::\n::: cell\nC\n:::\n::::"
+        result = convert_markdown(md)
+        assert 'ac:type="three_equal"' in result
+        assert result.count("<ac:layout-cell>") == 3

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/tests/test_reverse_converter.py

@@ -248,6 +248,158 @@ class TestMixedContent:
         assert len(result.unknown_macros) == 0
 
 
+class TestTaskListReverse:
+    def test_unchecked_task(self):
+        html = (
+            '<ac:task-list><ac:task>'
+            '<ac:task-id>1</ac:task-id>'
+            '<ac:task-status>incomplete</ac:task-status>'
+            '<ac:task-body>Buy milk</ac:task-body>'
+            '</ac:task></ac:task-list>'
+        )
+        result = convert_storage_to_markdown(html)
+        assert "[ ] Buy milk" in result.markdown
+
+    def test_checked_task(self):
+        html = (
+            '<ac:task-list><ac:task>'
+            '<ac:task-id>1</ac:task-id>'
+            '<ac:task-status>complete</ac:task-status>'
+            '<ac:task-body>Done item</ac:task-body>'
+            '</ac:task></ac:task-list>'
+        )
+        result = convert_storage_to_markdown(html)
+        assert "[x] Done item" in result.markdown
+
+
+class TestMathReverse:
+    def test_inline_math(self):
+        html = (
+            '<ac:structured-macro ac:name="mathinline">'
+            '<ac:plain-text-body><![CDATA[E=mc^2]]></ac:plain-text-body>'
+            '</ac:structured-macro>'
+        )
+        result = convert_storage_to_markdown(html)
+        assert "$E=mc^2$" in result.markdown
+
+    def test_block_math(self):
+        html = (
+            '<ac:structured-macro ac:name="mathblock">'
+            '<ac:plain-text-body><![CDATA[x^2 + y^2 = z^2]]></ac:plain-text-body>'
+            '</ac:structured-macro>'
+        )
+        result = convert_storage_to_markdown(html)
+        assert "$$" in result.markdown
+        assert "x^2 + y^2 = z^2" in result.markdown
+
+
+class TestDefinitionListReverse:
+    def test_basic_deflist(self):
+        html = "<dl><dt>Term</dt><dd>Definition here</dd></dl>"
+        result = convert_storage_to_markdown(html)
+        assert "Term" in result.markdown
+        assert ": Definition here" in result.markdown
+
+
+class TestFootnoteReverse:
+    def test_footnote_ref_and_def(self):
+        html = (
+            '<p>Text with <sup><a id="footnote-ref-1" href="#footnote-1">[1]</a></sup>.</p>'
+            '<hr /><ol><li id="footnote-1">Footnote text. '
+            '<a href="#footnote-ref-1">\u21a9</a></li></ol>'
+        )
+        result = convert_storage_to_markdown(html)
+        assert "[^1]" in result.markdown
+        assert "[^1]: Footnote text." in result.markdown
+
+
+class TestPanelReverse:
+    def test_panel_with_title(self):
+        html = (
+            '<ac:structured-macro ac:name="panel">'
+            '<ac:parameter ac:name="title">My Panel</ac:parameter>'
+            '<ac:rich-text-body><p>Panel content.</p></ac:rich-text-body>'
+            '</ac:structured-macro>'
+        )
+        result = convert_storage_to_markdown(html)
+        assert "::: panel My Panel" in result.markdown
+        assert "Panel content." in result.markdown
+        assert ":::" in result.markdown
+
+
+class TestExpandReverse:
+    def test_expand_with_title(self):
+        html = (
+            '<ac:structured-macro ac:name="expand">'
+            '<ac:parameter ac:name="title">Click me</ac:parameter>'
+            '<ac:rich-text-body><p>Hidden content.</p></ac:rich-text-body>'
+            '</ac:structured-macro>'
+        )
+        result = convert_storage_to_markdown(html)
+        assert "::: expand Click me" in result.markdown
+        assert "Hidden content." in result.markdown
+
+
+class TestLayoutReverse:
+    def test_layout_with_cells(self):
+        html = (
+            '<ac:layout><ac:layout-section ac:type="two_equal">'
+            '<ac:layout-cell><p>Left</p></ac:layout-cell>'
+            '<ac:layout-cell><p>Right</p></ac:layout-cell>'
+            '</ac:layout-section></ac:layout>'
+        )
+        result = convert_storage_to_markdown(html)
+        assert ":::: layout two-equal" in result.markdown
+        assert "::: cell" in result.markdown
+        assert "Left" in result.markdown
+        assert "Right" in result.markdown
+        assert "::::" in result.markdown
+
+
+class TestPluginRoundTrips:
+    """Test round-trip conversion for new plugin features."""
+
+    def test_task_list_round_trip(self):
+        from confpub.converter import convert_markdown
+        md = "- [ ] Todo\n- [x] Done\n"
+        storage = convert_markdown(md)
+        result = convert_storage_to_markdown(storage)
+        assert "[ ] Todo" in result.markdown
+        assert "[x] Done" in result.markdown
+
+    def test_deflist_round_trip(self):
+        from confpub.converter import convert_markdown
+        md = "Apple\n:   A fruit\n"
+        storage = convert_markdown(md)
+        result = convert_storage_to_markdown(storage)
+        assert "Apple" in result.markdown
+        assert ": A fruit" in result.markdown
+
+    def test_front_matter_stripped_round_trip(self):
+        from confpub.converter import convert_markdown
+        md = "---\ntitle: Test\n---\n\n# Hello\n"
+        storage = convert_markdown(md)
+        assert "title:" not in storage
+        assert "<h1>" in storage
+
+    def test_panel_round_trip(self):
+        from confpub.converter import convert_markdown
+        md = "::: panel My Title\nContent here.\n:::\n"
+        storage = convert_markdown(md)
+        result = convert_storage_to_markdown(storage)
+        assert "panel" in result.markdown.lower()
+        assert "Content here." in result.markdown
+
+    def test_layout_round_trip(self):
+        from confpub.converter import convert_markdown
+        md = ":::: layout two-equal\n::: cell\nLeft\n:::\n::: cell\nRight\n:::\n::::\n"
+        storage = convert_markdown(md)
+        result = convert_storage_to_markdown(storage)
+        assert "layout" in result.markdown
+        assert "Left" in result.markdown
+        assert "Right" in result.markdown
+
+
 class TestRoundTrip:
     """Test that content survives a round-trip through conversion."""
 

{confpub_cli-1.4.4 → confpub_cli-1.5.0}/uv.lock

@@ -356,8 +356,10 @@ name = "confpub-cli"
 source = { editable = "." }
 dependencies = [
     { name = "atlassian-python-api" },
+    { name = "beautifulsoup4" },
     { name = "keyring" },
     { name = "markdown-it-py", extra = ["linkify", "plugins"] },
+    { name = "markdownify" },
     { name = "orjson" },
     { name = "pydantic" },
     { name = "pyyaml" },
@@ -374,15 +376,17 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "atlassian-python-api", specifier = ">=3.41" },
+    { name = "beautifulsoup4", specifier = ">=4.12" },
     { name = "hatch", marker = "extra == 'dev'", specifier = ">=1.0" },
     { name = "keyring", specifier = ">=24.0" },
     { name = "markdown-it-py", extras = ["linkify", "plugins"], specifier = ">=3.0" },
+    { name = "markdownify", specifier = ">=0.14" },
     { name = "orjson", specifier = ">=3.9" },
     { name = "pydantic", specifier = ">=2.0" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0" },
     { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.0" },
     { name = "pyyaml", specifier = ">=6.0" },
-    { name = "typer", extras = ["all"], specifier = ">=0.9" },
+    { name = "typer", specifier = ">=0.9" },
 ]
 provides-extras = ["dev"]
 
@@ -823,6 +827,19 @@ plugins = [
     { name = "mdit-py-plugins" },
 ]
 
+[[package]]
+name = "markdownify"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3f/bc/c8c8eea5335341306b0fa7e1cb33c5e1c8d24ef70ddd684da65f41c49c92/markdownify-1.2.2.tar.gz", hash = "sha256:b274f1b5943180b031b699b199cbaeb1e2ac938b75851849a31fd0c3d6603d09", size = 18816, upload-time = "2025-11-16T19:21:18.565Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/ce/f1e3e9d959db134cedf06825fae8d5b294bd368aacdd0831a3975b7c4d55/markdownify-1.2.2-py3-none-any.whl", hash = "sha256:3f02d3cc52714084d6e589f70397b6fc9f2f3a8531481bf35e8cc39f975e186a", size = 15724, upload-time = "2025-11-16T19:21:17.622Z" },
+]
+
 [[package]]
 name = "mdit-py-plugins"
 version = "0.5.0"
@@ -1341,6 +1358,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
 ]
 
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
 [[package]]
 name = "soupsieve"
 version = "2.8.3"