conjira-cli 0.2.6__tar.gz → 0.2.7__tar.gz

{conjira_cli-0.2.6/src/conjira_cli.egg-info → conjira_cli-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conjira-cli
-Version: 0.2.6
+Version: 0.2.7
 Summary: Unofficial agent-friendly CLI for self-hosted Confluence and Jira
 Author: quanttraderkim
 License-Expression: MIT
@@ -47,7 +47,7 @@ If your team uses self-hosted Confluence and Jira, official cloud-native connect
 
 `conjira-cli` is built for that gap. It helps when you want to read Confluence pages, export them to Markdown, refresh stale exports from the live wiki, summarize inline comment threads, search Jira with JQL, or create and update content without hardcoding PATs into source files or chat transcripts.
 
-For report-style pages, it can also preserve a small set of Confluence-native presentation macros while still keeping Markdown as the source of truth. The current bridge covers Mermaid, Markdown callouts such as `> [!INFO]`, `> [!NOTE]`, `> [!TIP]`, and `> [!WARNING]`, expandable blocks with `> [!EXPAND]`, and inline status badges with `:status[In Progress]{color=yellow}`.
+For report-style pages, it can also preserve a small set of Confluence-native presentation macros while still keeping Markdown as the source of truth. The current bridge covers fenced code blocks (Confluence `code` macro), LaTeX formulas with ```` ```math ```` fences (Confluence `mathblock` macro), Mermaid, Markdown callouts such as `> [!INFO]`, `> [!NOTE]`, `> [!TIP]`, and `> [!WARNING]`, expandable blocks with `> [!EXPAND]`, and inline status badges with `:status[In Progress]{color=yellow}`.
 
 ## What you can do with it
 
@@ -484,7 +484,7 @@ The recommended pattern is to set `CONFLUENCE_EXPORT_DEFAULT_DIR` to an inbox or
 
 ## Markdown import notes
 
-Markdown upload is a best-effort conversion to Confluence storage HTML. It works well for common headings, paragraphs, lists, blockquotes, fenced code blocks, tables, links, images, simple wiki-style links, and the currently supported report macros (`mermaid`, callouts, `expand`, and `:status[Title]{color=blue}`). It is not a perfect round-trip for complex Confluence macros, merged tables, or deeply nested layouts, so treat Markdown import as a practical authoring path rather than a lossless document converter.
+Markdown upload is a best-effort conversion to Confluence storage HTML. It works well for common headings, paragraphs, lists, blockquotes, fenced code blocks, tables, links, images, simple wiki-style links, and the currently supported report macros (`code`, ```` ```math ```` for `mathblock`, `mermaid`, callouts, `expand`, and `:status[Title]{color=blue}`). Export keeps code, math, and other plain-text macro bodies as fenced blocks, so export → edit → upload does not drop formulas. It is not a perfect round-trip for complex Confluence macros, merged tables, or deeply nested layouts, so treat Markdown import as a practical authoring path rather than a lossless document converter.
 
 Use `--body-file` and `--append-file` only for storage HTML files. If your source file is Markdown, use `--body-markdown-file` or `--append-markdown-file` so the CLI converts it before upload.
 

{conjira_cli-0.2.6 → conjira_cli-0.2.7}/README.md

@@ -18,7 +18,7 @@ If your team uses self-hosted Confluence and Jira, official cloud-native connect
 
 `conjira-cli` is built for that gap. It helps when you want to read Confluence pages, export them to Markdown, refresh stale exports from the live wiki, summarize inline comment threads, search Jira with JQL, or create and update content without hardcoding PATs into source files or chat transcripts.
 
-For report-style pages, it can also preserve a small set of Confluence-native presentation macros while still keeping Markdown as the source of truth. The current bridge covers Mermaid, Markdown callouts such as `> [!INFO]`, `> [!NOTE]`, `> [!TIP]`, and `> [!WARNING]`, expandable blocks with `> [!EXPAND]`, and inline status badges with `:status[In Progress]{color=yellow}`.
+For report-style pages, it can also preserve a small set of Confluence-native presentation macros while still keeping Markdown as the source of truth. The current bridge covers fenced code blocks (Confluence `code` macro), LaTeX formulas with ```` ```math ```` fences (Confluence `mathblock` macro), Mermaid, Markdown callouts such as `> [!INFO]`, `> [!NOTE]`, `> [!TIP]`, and `> [!WARNING]`, expandable blocks with `> [!EXPAND]`, and inline status badges with `:status[In Progress]{color=yellow}`.
 
 ## What you can do with it
 
@@ -455,7 +455,7 @@ The recommended pattern is to set `CONFLUENCE_EXPORT_DEFAULT_DIR` to an inbox or
 
 ## Markdown import notes
 
-Markdown upload is a best-effort conversion to Confluence storage HTML. It works well for common headings, paragraphs, lists, blockquotes, fenced code blocks, tables, links, images, simple wiki-style links, and the currently supported report macros (`mermaid`, callouts, `expand`, and `:status[Title]{color=blue}`). It is not a perfect round-trip for complex Confluence macros, merged tables, or deeply nested layouts, so treat Markdown import as a practical authoring path rather than a lossless document converter.
+Markdown upload is a best-effort conversion to Confluence storage HTML. It works well for common headings, paragraphs, lists, blockquotes, fenced code blocks, tables, links, images, simple wiki-style links, and the currently supported report macros (`code`, ```` ```math ```` for `mathblock`, `mermaid`, callouts, `expand`, and `:status[Title]{color=blue}`). Export keeps code, math, and other plain-text macro bodies as fenced blocks, so export → edit → upload does not drop formulas. It is not a perfect round-trip for complex Confluence macros, merged tables, or deeply nested layouts, so treat Markdown import as a practical authoring path rather than a lossless document converter.
 
 Use `--body-file` and `--append-file` only for storage HTML files. If your source file is Markdown, use `--body-markdown-file` or `--append-markdown-file` so the CLI converts it before upload.
 

{conjira_cli-0.2.6 → conjira_cli-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conjira-cli"
-version = "0.2.6"
+version = "0.2.7"
 description = "Unofficial agent-friendly CLI for self-hosted Confluence and Jira"
 readme = "README.md"
 requires-python = ">=3.9"

{conjira_cli-0.2.6 → conjira_cli-0.2.7}/src/conjira_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.2.6"
+__version__ = "0.2.7"

{conjira_cli-0.2.6 → conjira_cli-0.2.7}/src/conjira_cli/markdown_export.py

@@ -212,11 +212,17 @@ class MarkdownExporter:
             if macro_name == "toc":
                 return ""
             if self.mermaid_macro_name and macro_name == self.mermaid_macro_name:
-                return self._render_mermaid_macro(elem)
+                return self._render_fenced_macro(elem, "mermaid")
             if macro_name == "status":
                 return self._render_status_token(elem) + "\n\n"
             if macro_name in _CALLOUT_MACRO_NAMES:
                 return self._render_callout_macro(elem, macro_name)
+            if macro_name == "code":
+                return self._render_fenced_macro(elem, self._extract_macro_parameter(elem, "language"))
+            if macro_name == "mathblock":
+                return self._render_fenced_macro(elem, "math")
+            if self._has_only_plain_text_body(elem):
+                return self._render_fenced_macro(elem, "")
             return self._render_children(elem, indent=indent)
         if name in {"h1", "h2", "h3", "h4", "h5", "h6"}:
             level = int(name[1])
@@ -295,6 +301,8 @@ class MarkdownExporter:
             macro_name = elem.attrib.get("{urn:ac}name")
             if macro_name == "status":
                 return self._render_status_token(elem)
+            if self._is_fenced_macro(elem):
+                return "\n" + self._render_block(elem, indent=0).strip() + "\n"
             return ""
         if name in {"ul", "ol", "table"}:
             return "\n" + self._render_block(elem, indent=1).strip() + "\n"
@@ -317,7 +325,7 @@ class MarkdownExporter:
 
             for grandchild in list(child):
                 grandchild_name = _local_name(grandchild.tag)
-                if grandchild_name in {"ul", "ol", "table"}:
+                if grandchild_name in {"ul", "ol", "table"} or self._is_fenced_macro(grandchild):
                     nested_text = self._render_block(grandchild, indent=indent + 1).rstrip()
                     if not nested_text:
                         continue
@@ -512,9 +520,25 @@ class MarkdownExporter:
         )
         return f"![{attachment_name}]({url})\n\n"
 
-    def _render_mermaid_macro(self, elem: ET.Element) -> str:
+    def _is_fenced_macro(self, elem: ET.Element) -> bool:
+        if _local_name(elem.tag) != "structured-macro":
+            return False
+        macro_name = elem.attrib.get("{urn:ac}name")
+        if macro_name in {"code", "mathblock"}:
+            return True
+        if self.mermaid_macro_name and macro_name == self.mermaid_macro_name:
+            return True
+        return self._has_only_plain_text_body(elem)
+
+    @staticmethod
+    def _has_only_plain_text_body(elem: ET.Element) -> bool:
+        child_names = {_local_name(child.tag) for child in list(elem)}
+        return "plain-text-body" in child_names and "rich-text-body" not in child_names
+
+    def _render_fenced_macro(self, elem: ET.Element, language: str) -> str:
         text = self._extract_macro_plain_text_body(elem).strip("\n")
-        return f"```mermaid\n{text}\n```\n\n" if text else "```mermaid\n```\n\n"
+        fence_language = "" if language.strip().lower() in {"", "none"} else language.strip()
+        return f"```{fence_language}\n{text}\n```\n\n"
 
     def _render_callout_macro(self, elem: ET.Element, macro_name: str) -> str:
         title = self._extract_macro_parameter(elem, "title")

{conjira_cli-0.2.6 → conjira_cli-0.2.7}/src/conjira_cli/markdown_import.py

@@ -126,7 +126,7 @@ def _parse_blocks(
             continue
 
         if _LIST_ITEM_RE.match(line):
-            block, i = _parse_list(lines, i, current_indent)
+            block, i = _parse_list(lines, i, current_indent, mermaid_macro_name=mermaid_macro_name)
             parts.append(block)
             continue
 
@@ -175,7 +175,9 @@ def _render_fenced_block(
     mermaid_macro_name: Optional[str],
 ) -> str:
     if mermaid_macro_name and language.lower() == "mermaid":
-        return _render_mermaid_macro(code, mermaid_macro_name)
+        return _render_plain_text_macro(code, mermaid_macro_name)
+    if language.lower() == "math":
+        return _render_plain_text_macro(code, "mathblock")
     return _render_code_macro(code, language)
 
 
@@ -191,7 +193,7 @@ def _render_code_macro(code: str, language: str) -> str:
     ).format(safe_language, cdata_code)
 
 
-def _render_mermaid_macro(code: str, macro_name: str) -> str:
+def _render_plain_text_macro(code: str, macro_name: str) -> str:
     safe_macro_name = html.escape(macro_name, quote=True)
     cdata_code = code.replace("]]>", "]]]]><![CDATA[>")
     return (
@@ -282,7 +284,13 @@ def _render_callout_macro(*, macro_name: str, title: str, body_html: str) -> str
     )
 
 
-def _parse_list(lines: list[str], start: int, indent: int) -> tuple[str, int]:
+def _parse_list(
+    lines: list[str],
+    start: int,
+    indent: int,
+    *,
+    mermaid_macro_name: Optional[str] = None,
+) -> tuple[str, int]:
     first_match = _LIST_ITEM_RE.match(lines[start])
     if first_match is None:
         raise ValueError("List parsing requires a list item")
@@ -302,7 +310,7 @@ def _parse_list(lines: list[str], start: int, indent: int) -> tuple[str, int]:
         if current_indent < indent or current_ordered != ordered:
             break
         if current_indent > indent:
-            nested, i = _parse_list(lines, i, current_indent)
+            nested, i = _parse_list(lines, i, current_indent, mermaid_macro_name=mermaid_macro_name)
             if items:
                 items[-1] = items[-1].replace("</li>", nested + "</li>", 1)
             continue
@@ -326,13 +334,22 @@ def _parse_list(lines: list[str], start: int, indent: int) -> tuple[str, int]:
                 if nested_indent == indent and nested_ordered == ordered:
                     break
                 if nested_indent > indent:
-                    nested_html, i = _parse_list(lines, i, nested_indent)
+                    nested_html, i = _parse_list(lines, i, nested_indent, mermaid_macro_name=mermaid_macro_name)
                     content_parts.append(nested_html)
                     continue
                 if nested_indent < indent:
                     break
 
             continuation_indent = _leading_spaces(next_line)
+            if continuation_indent > indent and next_line.strip().startswith("```"):
+                block_html, i = _parse_nested_fenced_code(
+                    lines,
+                    i,
+                    fence_indent=continuation_indent,
+                    mermaid_macro_name=mermaid_macro_name,
+                )
+                content_parts.append(block_html)
+                continue
             if continuation_indent > indent:
                 content_parts.append(" " + _render_inline(next_line.strip()))
                 i += 1
@@ -344,6 +361,27 @@ def _parse_list(lines: list[str], start: int, indent: int) -> tuple[str, int]:
     return "<{0}>{1}</{0}>".format(tag, "".join(items)), i
 
 
+def _parse_nested_fenced_code(
+    lines: list[str],
+    start: int,
+    *,
+    fence_indent: int,
+    mermaid_macro_name: Optional[str],
+) -> tuple[str, int]:
+    """Parse a fenced block indented under a list item, dedenting it by the fence indent."""
+    fence = lines[start].strip()[:3]
+    dedented: list[str] = []
+    i = start
+    while i < len(lines):
+        line = lines[i]
+        dedented.append(line[fence_indent:] if line[:fence_indent].strip() == "" else line.lstrip())
+        i += 1
+        if i - 1 > start and line.strip().startswith(fence):
+            break
+    block_html, _ = _parse_fenced_code(dedented, 0, mermaid_macro_name=mermaid_macro_name)
+    return block_html, i
+
+
 def _parse_table(lines: list[str], start: int) -> tuple[str, int]:
     rows: list[list[str]] = []
     i = start

{conjira_cli-0.2.6 → conjira_cli-0.2.7}/src/conjira_cli/section_edit.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import copy
 import re
+import uuid
 import xml.etree.ElementTree as ET
 from dataclasses import dataclass
 
@@ -11,6 +12,7 @@ ET.register_namespace("ri", "urn:ri")
 
 
 _WRAPPED_ROOT_PREFIX = '<root xmlns:ac="urn:ac" xmlns:ri="urn:ri">'
+_CDATA_RE = re.compile(r"<!\[CDATA\[.*?\]\]>", re.DOTALL)
 
 
 class SectionEditError(ValueError):
@@ -36,13 +38,37 @@ class HeadingInsertionResult:
     updated_body_html: str
 
 
+class _CdataVault:
+    """Hide CDATA sections from the XML parser and restore them after serialization.
+
+    ElementTree folds ``<![CDATA[...]]>`` into ordinary text and writes it back
+    escaped, which Confluence no longer treats as a plain-text macro body.
+    """
+
+    def __init__(self) -> None:
+        self._token = "conjira-cdata-" + uuid.uuid4().hex
+        self._sections: list[str] = []
+        self._placeholder_re = re.compile(re.escape(self._token) + r"-(\d+)-")
+
+    def protect(self, html: str) -> str:
+        def _stash(match: re.Match[str]) -> str:
+            self._sections.append(match.group(0))
+            return "{0}-{1}-".format(self._token, len(self._sections) - 1)
+
+        return _CDATA_RE.sub(_stash, html)
+
+    def restore(self, html: str) -> str:
+        return self._placeholder_re.sub(lambda match: self._sections[int(match.group(1))], html)
+
+
 def replace_section_html(
     body_html: str,
     *,
     heading: str,
     replacement_html: str,
 ) -> SectionReplacementResult:
-    root = _parse_fragment(body_html)
+    vault = _CdataVault()
+    root = _parse_fragment(vault.protect(body_html))
     children = list(root)
     match_index, match_elem, match_level = _find_unique_heading(
         children,
@@ -59,7 +85,7 @@ def replace_section_html(
     old_section_children = children[match_index + 1 : end_index]
     old_section_html = _serialize_elements(old_section_children)
 
-    new_root = _parse_fragment(replacement_html)
+    new_root = _parse_fragment(vault.protect(replacement_html))
     new_children = [copy.deepcopy(child) for child in list(new_root)]
 
     for child in old_section_children:
@@ -72,9 +98,9 @@ def replace_section_html(
         heading=heading,
         matched_heading=_element_text(match_elem),
         heading_level=match_level,
-        old_section_html=old_section_html,
-        new_section_html=_serialize_elements(new_children),
-        updated_body_html=_serialize_root(root),
+        old_section_html=vault.restore(old_section_html),
+        new_section_html=vault.restore(_serialize_elements(new_children)),
+        updated_body_html=vault.restore(_serialize_root(root)),
     )
 
 
@@ -84,7 +110,8 @@ def insert_after_heading_html(
     heading: str,
     inserted_html: str,
 ) -> HeadingInsertionResult:
-    root = _parse_fragment(body_html)
+    vault = _CdataVault()
+    root = _parse_fragment(vault.protect(body_html))
     children = list(root)
     match_index, match_elem, match_level = _find_unique_heading(
         children,
@@ -92,7 +119,7 @@ def insert_after_heading_html(
         action_name="insert-after-heading",
     )
 
-    new_root = _parse_fragment(inserted_html)
+    new_root = _parse_fragment(vault.protect(inserted_html))
     new_children = [copy.deepcopy(child) for child in list(new_root)]
 
     insert_at = match_index + 1
@@ -103,8 +130,8 @@ def insert_after_heading_html(
         heading=heading,
         matched_heading=_element_text(match_elem),
         heading_level=match_level,
-        inserted_html=_serialize_elements(new_children),
-        updated_body_html=_serialize_root(root),
+        inserted_html=vault.restore(_serialize_elements(new_children)),
+        updated_body_html=vault.restore(_serialize_root(root)),
     )
 
 

{conjira_cli-0.2.6 → conjira_cli-0.2.7/src/conjira_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conjira-cli
-Version: 0.2.6
+Version: 0.2.7
 Summary: Unofficial agent-friendly CLI for self-hosted Confluence and Jira
 Author: quanttraderkim
 License-Expression: MIT
@@ -47,7 +47,7 @@ If your team uses self-hosted Confluence and Jira, official cloud-native connect
 
 `conjira-cli` is built for that gap. It helps when you want to read Confluence pages, export them to Markdown, refresh stale exports from the live wiki, summarize inline comment threads, search Jira with JQL, or create and update content without hardcoding PATs into source files or chat transcripts.
 
-For report-style pages, it can also preserve a small set of Confluence-native presentation macros while still keeping Markdown as the source of truth. The current bridge covers Mermaid, Markdown callouts such as `> [!INFO]`, `> [!NOTE]`, `> [!TIP]`, and `> [!WARNING]`, expandable blocks with `> [!EXPAND]`, and inline status badges with `:status[In Progress]{color=yellow}`.
+For report-style pages, it can also preserve a small set of Confluence-native presentation macros while still keeping Markdown as the source of truth. The current bridge covers fenced code blocks (Confluence `code` macro), LaTeX formulas with ```` ```math ```` fences (Confluence `mathblock` macro), Mermaid, Markdown callouts such as `> [!INFO]`, `> [!NOTE]`, `> [!TIP]`, and `> [!WARNING]`, expandable blocks with `> [!EXPAND]`, and inline status badges with `:status[In Progress]{color=yellow}`.
 
 ## What you can do with it
 
@@ -484,7 +484,7 @@ The recommended pattern is to set `CONFLUENCE_EXPORT_DEFAULT_DIR` to an inbox or
 
 ## Markdown import notes
 
-Markdown upload is a best-effort conversion to Confluence storage HTML. It works well for common headings, paragraphs, lists, blockquotes, fenced code blocks, tables, links, images, simple wiki-style links, and the currently supported report macros (`mermaid`, callouts, `expand`, and `:status[Title]{color=blue}`). It is not a perfect round-trip for complex Confluence macros, merged tables, or deeply nested layouts, so treat Markdown import as a practical authoring path rather than a lossless document converter.
+Markdown upload is a best-effort conversion to Confluence storage HTML. It works well for common headings, paragraphs, lists, blockquotes, fenced code blocks, tables, links, images, simple wiki-style links, and the currently supported report macros (`code`, ```` ```math ```` for `mathblock`, `mermaid`, callouts, `expand`, and `:status[Title]{color=blue}`). Export keeps code, math, and other plain-text macro bodies as fenced blocks, so export → edit → upload does not drop formulas. It is not a perfect round-trip for complex Confluence macros, merged tables, or deeply nested layouts, so treat Markdown import as a practical authoring path rather than a lossless document converter.
 
 Use `--body-file` and `--append-file` only for storage HTML files. If your source file is Markdown, use `--body-markdown-file` or `--append-markdown-file` so the CLI converts it before upload.
 

{conjira_cli-0.2.6 → conjira_cli-0.2.7}/tests/test_markdown_export.py

@@ -161,7 +161,7 @@ class MarkdownExportTests(unittest.TestCase):
 
         self.assertIn("```mermaid\ngraph TD\nA-->B\n```", result)
 
-    def test_mermaid_macro_is_ignored_without_config(self) -> None:
+    def test_mermaid_macro_keeps_source_as_plain_fence_without_config(self) -> None:
         exporter = MarkdownExporter(base_url="https://confluence.example.com", page_id="123")
         html = (
             '<ac:structured-macro ac:name="mermaid-macro" ac:schema-version="1">'
@@ -171,7 +171,7 @@ class MarkdownExportTests(unittest.TestCase):
 
         result = exporter.convert_fragment(html)
 
-        self.assertEqual(result.strip(), "")
+        self.assertEqual(result.strip(), "```\ngraph TD\nA-->B\n```")
 
     def test_callout_macro_renders_as_markdown_callout(self) -> None:
         exporter = MarkdownExporter(base_url="https://confluence.example.com", page_id="123")
@@ -295,3 +295,141 @@ class MarkdownExportTests(unittest.TestCase):
         for line in result.splitlines():
             if "Review" in line and line.strip().startswith("|"):
                 self.assertIn("\\|", line, "Pipe in list item should be escaped")
+
+
+class PlainTextMacroExportTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.exporter = MarkdownExporter(base_url="https://confluence.example.com", page_id="12345")
+
+    def test_code_macro_renders_as_fenced_block_with_language(self) -> None:
+        html = (
+            "<h2>Formula</h2>"
+            '<ac:structured-macro ac:name="code" ac:schema-version="1">'
+            '<ac:parameter ac:name="language">text</ac:parameter>'
+            '<ac:parameter ac:name="theme">Default</ac:parameter>'
+            "<ac:plain-text-body><![CDATA[Credit = Cost × E\n  + InfraCredit]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+        )
+
+        result = self.exporter.convert_fragment(html)
+
+        self.assertIn("## Formula", result)
+        self.assertIn("```text\nCredit = Cost × E\n  + InfraCredit\n```", result)
+        self.assertNotIn("Default", result)
+
+    def test_code_macro_without_language_renders_as_bare_fence(self) -> None:
+        for language_xml in ("", '<ac:parameter ac:name="language">none</ac:parameter>'):
+            html = (
+                '<ac:structured-macro ac:name="code" ac:schema-version="1">'
+                + language_xml
+                + "<ac:plain-text-body><![CDATA[plain body]]></ac:plain-text-body>"
+                "</ac:structured-macro>"
+            )
+
+            result = self.exporter.convert_fragment(html)
+
+            self.assertIn("```\nplain body\n```", result)
+            self.assertNotIn("```none", result)
+
+    def test_mathblock_macro_renders_as_math_fence_with_latex_verbatim(self) -> None:
+        html = (
+            '<ac:structured-macro ac:name="mathblock" ac:schema-version="1">'
+            '<ac:parameter ac:name="alignment">left</ac:parameter>'
+            "<ac:plain-text-body><![CDATA[\\text{Credit} = \\sum_{i=1}^{N} a_i \\times E]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+        )
+
+        result = self.exporter.convert_fragment(html)
+
+        self.assertIn("```math\n\\text{Credit} = \\sum_{i=1}^{N} a_i \\times E\n```", result)
+        self.assertNotIn("left", result)
+
+    def test_unknown_plain_text_macro_renders_as_plain_fence_but_rich_macros_keep_children(self) -> None:
+        html = (
+            '<ac:structured-macro ac:name="noformat" ac:schema-version="1">'
+            "<ac:plain-text-body><![CDATA[raw  text]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+            '<ac:structured-macro ac:name="panel" ac:schema-version="1">'
+            "<ac:rich-text-body><p>Panel text</p></ac:rich-text-body>"
+            "</ac:structured-macro>"
+        )
+
+        result = self.exporter.convert_fragment(html)
+
+        self.assertIn("```\nraw  text\n```", result)
+        self.assertIn("Panel text", result)
+        self.assertNotIn("```\nPanel text", result)
+
+    def test_code_and_math_macros_survive_export_import_round_trip(self) -> None:
+        from conjira_cli.markdown_import import markdown_to_storage_html
+
+        html = (
+            "<h2>Formula</h2>"
+            '<ac:structured-macro ac:name="code" ac:schema-version="1">'
+            '<ac:parameter ac:name="language">text</ac:parameter>'
+            "<ac:plain-text-body><![CDATA[Credit = Cost × E]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+            '<ac:structured-macro ac:name="mathblock" ac:schema-version="1">'
+            "<ac:plain-text-body><![CDATA[\\text{Credit} = \\text{Cost} \\times E]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+        )
+
+        round_tripped = markdown_to_storage_html(self.exporter.convert_fragment(html))
+
+        self.assertIn('<ac:structured-macro ac:name="code" ac:schema-version="1">', round_tripped)
+        self.assertIn('<ac:parameter ac:name="language">text</ac:parameter>', round_tripped)
+        self.assertIn("<![CDATA[Credit = Cost × E]]>", round_tripped)
+        self.assertIn('<ac:structured-macro ac:name="mathblock" ac:schema-version="1">', round_tripped)
+        self.assertIn("<![CDATA[\\text{Credit} = \\text{Cost} \\times E]]>", round_tripped)
+
+    def test_plain_text_macro_inside_list_item_renders_as_nested_fence(self) -> None:
+        html = (
+            "<ul><li>Ledger"
+            '<ac:structured-macro ac:name="mathblock" ac:schema-version="1">'
+            "<ac:plain-text-body><![CDATA[\\text{Ledger} = \\text{Credit}]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+            "</li><li>Next item</li></ul>"
+        )
+
+        result = self.exporter.convert_fragment(html)
+
+        self.assertIn("- Ledger\n", result)
+        self.assertIn("```math\n  \\text{Ledger} = \\text{Credit}\n  ```", result)
+        self.assertIn("- Next item", result)
+
+    def test_math_macro_inside_list_item_survives_round_trip(self) -> None:
+        from conjira_cli.markdown_import import markdown_to_storage_html
+
+        html = (
+            "<ul><li>Ledger"
+            '<ac:structured-macro ac:name="mathblock" ac:schema-version="1">'
+            "<ac:plain-text-body><![CDATA[\\text{Ledger} = \\text{Credit}]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+            "</li><li>Next item</li></ul>"
+        )
+
+        round_tripped = markdown_to_storage_html(self.exporter.convert_fragment(html))
+
+        self.assertIn(
+            '<li>Ledger<ac:structured-macro ac:name="mathblock" ac:schema-version="1">'
+            "<ac:plain-text-body><![CDATA[\\text{Ledger} = \\text{Credit}]]></ac:plain-text-body>"
+            "</ac:structured-macro></li>",
+            round_tripped,
+        )
+        self.assertIn("<li>Next item</li>", round_tripped)
+
+    def test_plain_text_macro_wrapped_in_paragraph_renders_as_fence(self) -> None:
+        html = (
+            "<p>Before"
+            '<ac:structured-macro ac:name="code" ac:schema-version="1">'
+            '<ac:parameter ac:name="language">text</ac:parameter>'
+            "<ac:plain-text-body><![CDATA[x = 1]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+            "After</p>"
+        )
+
+        result = self.exporter.convert_fragment(html)
+
+        self.assertIn("Before", result)
+        self.assertIn("```text\nx = 1\n```", result)
+        self.assertIn("After", result)

{conjira_cli-0.2.6 → conjira_cli-0.2.7}/tests/test_markdown_import.py

@@ -298,3 +298,31 @@ class MarkdownImportTests(unittest.TestCase):
         # Whole cell goes through as raw HTML; trailing markdown is NOT rendered.
         self.assertIn("<ul><li>x</li></ul> trailing [link](http://example.com)", result)
         self.assertNotIn('<a href="http://example.com">', result)
+
+
+class MathFenceImportTests(unittest.TestCase):
+    def test_math_fence_becomes_mathblock_macro(self) -> None:
+        result = markdown_to_storage_html("```math\n\\text{Credit} = a \\times E\n```\n")
+
+        self.assertIn(
+            '<ac:structured-macro ac:name="mathblock" ac:schema-version="1">',
+            result,
+        )
+        self.assertIn(
+            "<ac:plain-text-body><![CDATA[\\text{Credit} = a \\times E]]></ac:plain-text-body>",
+            result,
+        )
+        self.assertNotIn('ac:name="code"', result)
+
+    def test_indented_math_fence_inside_list_item_becomes_nested_mathblock(self) -> None:
+        markdown = "- Ledger\n  ```math\n  x = 1\n  ```\n- Next item\n"
+
+        result = markdown_to_storage_html(markdown)
+
+        self.assertIn(
+            "<li>Ledger<ac:structured-macro ac:name=\"mathblock\" ac:schema-version=\"1\">"
+            "<ac:plain-text-body><![CDATA[x = 1]]></ac:plain-text-body></ac:structured-macro></li>",
+            result,
+        )
+        self.assertIn("<li>Next item</li>", result)
+        self.assertNotIn("```", result)

conjira_cli-0.2.7/tests/test_section_edit.py

@@ -0,0 +1,180 @@
+import unittest
+
+from conjira_cli.section_edit import (
+    SectionEditError,
+    insert_after_heading_html,
+    replace_section_html,
+)
+
+
+class SectionEditTests(unittest.TestCase):
+    def test_replace_section_html_replaces_heading_block_until_next_peer_heading(self) -> None:
+        body_html = (
+            "<h1>Guide</h1>"
+            "<p>Intro</p>"
+            "<h2>Install</h2>"
+            "<p>Old install step</p>"
+            "<h3>Nested detail</h3>"
+            "<p>Nested note</p>"
+            "<h2>Usage</h2>"
+            "<p>Run command</p>"
+        )
+
+        result = replace_section_html(
+            body_html,
+            heading="Install",
+            replacement_html="<p>New install step</p><ul><li>Do this first</li></ul>",
+        )
+
+        self.assertEqual(result.matched_heading, "Install")
+        self.assertEqual(result.heading_level, 2)
+        self.assertIn("<p>Old install step</p>", result.old_section_html)
+        self.assertIn("<h3>Nested detail</h3>", result.old_section_html)
+        self.assertIn("<p>New install step</p>", result.new_section_html)
+        self.assertIn("<ul><li>Do this first</li></ul>", result.updated_body_html)
+        self.assertIn("<h2>Usage</h2>", result.updated_body_html)
+        self.assertNotIn("Old install step", result.updated_body_html)
+
+    def test_replace_section_html_fails_when_heading_missing(self) -> None:
+        with self.assertRaises(SectionEditError):
+            replace_section_html(
+                "<h1>Guide</h1><p>Body</p>",
+                heading="Install",
+                replacement_html="<p>Replacement</p>",
+            )
+
+    def test_replace_section_html_fails_when_heading_ambiguous(self) -> None:
+        with self.assertRaises(SectionEditError):
+            replace_section_html(
+                "<h2>Install</h2><p>A</p><h2>Install</h2><p>B</p>",
+                heading="Install",
+                replacement_html="<p>Replacement</p>",
+            )
+
+    def test_insert_after_heading_html_inserts_immediately_after_heading(self) -> None:
+        body_html = (
+            "<h1>Guide</h1>"
+            "<p>Intro</p>"
+            "<h2>Install</h2>"
+            "<p>Old install step</p>"
+            "<h2>Usage</h2>"
+            "<p>Run command</p>"
+        )
+
+        result = insert_after_heading_html(
+            body_html,
+            heading="Install",
+            inserted_html="<p>New note</p><ul><li>Check this first</li></ul>",
+        )
+
+        self.assertEqual(result.matched_heading, "Install")
+        self.assertEqual(result.heading_level, 2)
+        self.assertIn("<p>New note</p>", result.inserted_html)
+        self.assertIn("<ul><li>Check this first</li></ul>", result.updated_body_html)
+        self.assertIn(
+            "<h2>Install</h2><p>New note</p><ul><li>Check this first</li></ul><p>Old install step</p>",
+            result.updated_body_html,
+        )
+
+    def test_insert_after_heading_html_fails_when_heading_missing(self) -> None:
+        with self.assertRaises(SectionEditError):
+            insert_after_heading_html(
+                "<h1>Guide</h1><p>Body</p>",
+                heading="Install",
+                inserted_html="<p>Inserted</p>",
+            )
+
+    def test_insert_after_heading_html_fails_when_heading_ambiguous(self) -> None:
+        with self.assertRaises(SectionEditError):
+            insert_after_heading_html(
+                "<h2>Install</h2><p>A</p><h2>Install</h2><p>B</p>",
+                heading="Install",
+                inserted_html="<p>Inserted</p>",
+            )
+
+
+_CODE_MACRO = (
+    '<ac:structured-macro ac:name="code" ac:schema-version="1">'
+    '<ac:parameter ac:name="language">text</ac:parameter>'
+    "<ac:plain-text-body><![CDATA[Credit = Cost × E]]></ac:plain-text-body>"
+    "</ac:structured-macro>"
+)
+
+
+class SectionEditCdataTests(unittest.TestCase):
+    def test_replace_section_keeps_cdata_macro_body_outside_edited_section(self) -> None:
+        body_html = (
+            "<h2>Formula</h2>"
+            + _CODE_MACRO
+            + "<h2>Other</h2><p>old</p>"
+        )
+
+        result = replace_section_html(
+            body_html,
+            heading="Other",
+            replacement_html="<p>new</p>",
+        )
+
+        self.assertIn("<![CDATA[Credit = Cost × E]]>", result.updated_body_html)
+        self.assertIn("<p>new</p>", result.updated_body_html)
+        self.assertNotIn("<p>old</p>", result.updated_body_html)
+
+    def test_replace_section_keeps_cdata_in_replacement_and_in_replaced_section(self) -> None:
+        old_macro = _CODE_MACRO.replace("Credit = Cost × E", "old formula")
+        body_html = "<h2>Formula</h2>" + old_macro + "<h2>Other</h2><p>text</p>"
+
+        result = replace_section_html(
+            body_html,
+            heading="Formula",
+            replacement_html=_CODE_MACRO + "<p>note</p>",
+        )
+
+        self.assertIn("<![CDATA[old formula]]>", result.old_section_html)
+        self.assertIn("<![CDATA[Credit = Cost × E]]>", result.new_section_html)
+        self.assertIn("<![CDATA[Credit = Cost × E]]>", result.updated_body_html)
+        self.assertNotIn("old formula", result.updated_body_html)
+
+    def test_insert_after_heading_keeps_cdata_in_body_and_inserted_fragment(self) -> None:
+        existing_macro = _CODE_MACRO.replace("Credit = Cost × E", "existing formula")
+        body_html = "<h2>Formula</h2>" + existing_macro + "<h2>Other</h2><p>text</p>"
+
+        result = insert_after_heading_html(
+            body_html,
+            heading="Other",
+            inserted_html=_CODE_MACRO,
+        )
+
+        self.assertIn("<![CDATA[Credit = Cost × E]]>", result.inserted_html)
+        self.assertIn("<![CDATA[existing formula]]>", result.updated_body_html)
+        self.assertIn("<![CDATA[Credit = Cost × E]]>", result.updated_body_html)
+
+    def test_multiple_cdata_sections_with_special_characters_are_restored_in_place(self) -> None:
+        math_macro = (
+            '<ac:structured-macro ac:name="mathblock" ac:schema-version="1">'
+            "<ac:plain-text-body><![CDATA[\\text{Credit} = \\sum_{i} a_i < b & c]]></ac:plain-text-body>"
+            "</ac:structured-macro>"
+        )
+        second_code = _CODE_MACRO.replace("Credit = Cost × E", "if (a < b && c) { run(); }")
+        body_html = (
+            "<h2>Formula</h2>" + _CODE_MACRO + math_macro
+            + "<h2>Code</h2>" + second_code
+            + "<h2>Other</h2><p>old</p>"
+        )
+
+        result = replace_section_html(
+            body_html,
+            heading="Other",
+            replacement_html="<p>new</p>",
+        )
+
+        updated = result.updated_body_html
+        expected_in_order = [
+            "<![CDATA[Credit = Cost × E]]>",
+            "<![CDATA[\\text{Credit} = \\sum_{i} a_i < b & c]]>",
+            "<![CDATA[if (a < b && c) { run(); }]]>",
+            "<h2>Other</h2><p>new</p>",
+        ]
+        positions = [updated.find(piece) for piece in expected_in_order]
+        self.assertTrue(all(position >= 0 for position in positions), updated)
+        self.assertEqual(positions, sorted(positions), updated)
+        self.assertNotIn("conjira-cdata", updated)

conjira_cli-0.2.6/tests/test_section_edit.py

@@ -1,93 +0,0 @@
-import unittest
-
-from conjira_cli.section_edit import (
-    SectionEditError,
-    insert_after_heading_html,
-    replace_section_html,
-)
-
-
-class SectionEditTests(unittest.TestCase):
-    def test_replace_section_html_replaces_heading_block_until_next_peer_heading(self) -> None:
-        body_html = (
-            "<h1>Guide</h1>"
-            "<p>Intro</p>"
-            "<h2>Install</h2>"
-            "<p>Old install step</p>"
-            "<h3>Nested detail</h3>"
-            "<p>Nested note</p>"
-            "<h2>Usage</h2>"
-            "<p>Run command</p>"
-        )
-
-        result = replace_section_html(
-            body_html,
-            heading="Install",
-            replacement_html="<p>New install step</p><ul><li>Do this first</li></ul>",
-        )
-
-        self.assertEqual(result.matched_heading, "Install")
-        self.assertEqual(result.heading_level, 2)
-        self.assertIn("<p>Old install step</p>", result.old_section_html)
-        self.assertIn("<h3>Nested detail</h3>", result.old_section_html)
-        self.assertIn("<p>New install step</p>", result.new_section_html)
-        self.assertIn("<ul><li>Do this first</li></ul>", result.updated_body_html)
-        self.assertIn("<h2>Usage</h2>", result.updated_body_html)
-        self.assertNotIn("Old install step", result.updated_body_html)
-
-    def test_replace_section_html_fails_when_heading_missing(self) -> None:
-        with self.assertRaises(SectionEditError):
-            replace_section_html(
-                "<h1>Guide</h1><p>Body</p>",
-                heading="Install",
-                replacement_html="<p>Replacement</p>",
-            )
-
-    def test_replace_section_html_fails_when_heading_ambiguous(self) -> None:
-        with self.assertRaises(SectionEditError):
-            replace_section_html(
-                "<h2>Install</h2><p>A</p><h2>Install</h2><p>B</p>",
-                heading="Install",
-                replacement_html="<p>Replacement</p>",
-            )
-
-    def test_insert_after_heading_html_inserts_immediately_after_heading(self) -> None:
-        body_html = (
-            "<h1>Guide</h1>"
-            "<p>Intro</p>"
-            "<h2>Install</h2>"
-            "<p>Old install step</p>"
-            "<h2>Usage</h2>"
-            "<p>Run command</p>"
-        )
-
-        result = insert_after_heading_html(
-            body_html,
-            heading="Install",
-            inserted_html="<p>New note</p><ul><li>Check this first</li></ul>",
-        )
-
-        self.assertEqual(result.matched_heading, "Install")
-        self.assertEqual(result.heading_level, 2)
-        self.assertIn("<p>New note</p>", result.inserted_html)
-        self.assertIn("<ul><li>Check this first</li></ul>", result.updated_body_html)
-        self.assertIn(
-            "<h2>Install</h2><p>New note</p><ul><li>Check this first</li></ul><p>Old install step</p>",
-            result.updated_body_html,
-        )
-
-    def test_insert_after_heading_html_fails_when_heading_missing(self) -> None:
-        with self.assertRaises(SectionEditError):
-            insert_after_heading_html(
-                "<h1>Guide</h1><p>Body</p>",
-                heading="Install",
-                inserted_html="<p>Inserted</p>",
-            )
-
-    def test_insert_after_heading_html_fails_when_heading_ambiguous(self) -> None:
-        with self.assertRaises(SectionEditError):
-            insert_after_heading_html(
-                "<h2>Install</h2><p>A</p><h2>Install</h2><p>B</p>",
-                heading="Install",
-                inserted_html="<p>Inserted</p>",
-            )