mkdocs2confluence 0.10.0__tar.gz → 0.10.2__tar.gz

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.10.0
+Version: 0.10.2
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later
@@ -52,6 +52,8 @@ Dynamic: license-file
 [![Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 [![mypy](https://img.shields.io/badge/type--checked-mypy-blue.svg)](https://mypy-lang.org/)
 [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![SLSA Level 3](https://slsa.dev/images/gh-badge-level3.svg)](https://slsa.dev)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/jeckyl2010/mkdocs2confluence/badge)](https://securityscorecards.dev/viewer/?uri=github.com/jeckyl2010/mkdocs2confluence)
 
 A Python CLI tool that compiles MkDocs-flavoured Markdown into native Confluence storage XHTML and publishes it directly to Confluence Cloud. It is a **compiler/transpiler**, not an HTML converter — every construct maps to its native Confluence equivalent, so pages look and behave like hand-authored Confluence content.
 

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/README.md

@@ -11,6 +11,8 @@
 [![Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 [![mypy](https://img.shields.io/badge/type--checked-mypy-blue.svg)](https://mypy-lang.org/)
 [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![SLSA Level 3](https://slsa.dev/images/gh-badge-level3.svg)](https://slsa.dev)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/jeckyl2010/mkdocs2confluence/badge)](https://securityscorecards.dev/viewer/?uri=github.com/jeckyl2010/mkdocs2confluence)
 
 A Python CLI tool that compiles MkDocs-flavoured Markdown into native Confluence storage XHTML and publishes it directly to Confluence Cloud. It is a **compiler/transpiler**, not an HTML converter — every construct maps to its native Confluence equivalent, so pages look and behave like hand-authored Confluence content.
 

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.10.0"
+version = "0.10.2"
 description = "Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/src/mkdocs2confluence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.10.0
+Version: 0.10.2
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later
@@ -52,6 +52,8 @@ Dynamic: license-file
 [![Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 [![mypy](https://img.shields.io/badge/type--checked-mypy-blue.svg)](https://mypy-lang.org/)
 [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![SLSA Level 3](https://slsa.dev/images/gh-badge-level3.svg)](https://slsa.dev)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/jeckyl2010/mkdocs2confluence/badge)](https://securityscorecards.dev/viewer/?uri=github.com/jeckyl2010/mkdocs2confluence)
 
 A Python CLI tool that compiles MkDocs-flavoured Markdown into native Confluence storage XHTML and publishes it directly to Confluence Cloud. It is a **compiler/transpiler**, not an HTML converter — every construct maps to its native Confluence equivalent, so pages look and behave like hand-authored Confluence content.
 

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/src/mkdocs_to_confluence/cli.py

@@ -312,7 +312,7 @@ def _cmd_preview(args: argparse.Namespace) -> None:
     config = load_config(config_path)
     configure_styles(config.extra_styles)
 
-    nodes = resolve_nav(config)
+    all_nodes = resolve_nav(config)
 
     section_given = bool(getattr(args, "section", None))
     page_given = bool(args.page)
@@ -326,8 +326,9 @@ def _cmd_preview(args: argparse.Namespace) -> None:
         sys.exit(1)
 
     # Resolve section subtree (both single-page and section-mode use this)
+    nodes = all_nodes
     if section_given:
-        section_node = find_section(nodes, args.section) or find_section_by_folder(nodes, args.section)
+        section_node = find_section(all_nodes, args.section) or find_section_by_folder(all_nodes, args.section)
         if section_node is None:
             print(f"error: section '{args.section}' not found in nav.", file=sys.stderr)
             sys.exit(1)
@@ -347,7 +348,7 @@ def _cmd_preview(args: argparse.Namespace) -> None:
             out_dir, index_name = _parse_out_path(args.out)
         out_dir.mkdir(parents=True, exist_ok=True)
 
-        link_map = build_link_map(nodes)
+        link_map = build_link_map(all_nodes)
         page_link_map = {
             node.title: f"{Path(node.docs_path).stem}.html"
             for node in pages
@@ -479,11 +480,12 @@ def _cmd_publish(args: argparse.Namespace) -> None:
         )
         sys.exit(1)
 
-    nav_nodes = resolve_nav(config)
+    all_nav_nodes = resolve_nav(config)
+    nav_nodes = all_nav_nodes
 
     # Section filter (--section takes precedence; --page is a secondary filter)
     if getattr(args, "section", None):
-        section_node = find_section(nav_nodes, args.section) or find_section_by_folder(nav_nodes, args.section)
+        section_node = find_section(all_nav_nodes, args.section) or find_section_by_folder(all_nav_nodes, args.section)
         if section_node is None:
             print(f"error: section '{args.section}' not found in nav.", file=sys.stderr)
             sys.exit(1)
@@ -529,7 +531,10 @@ def _cmd_publish(args: argparse.Namespace) -> None:
                     file=sys.stderr,
                 )
                 sys.exit(1)
-            plan = plan_publish(nav_nodes, client, config, conf_config, space_id=space_id, quiet=args.quiet)
+            plan = plan_publish(
+                nav_nodes, client, config, conf_config,
+                space_id=space_id, quiet=args.quiet, full_nav_nodes=all_nav_nodes,
+            )
             # --prune is silently disabled for partial publishes (--page / --section)
             # because published_ids would only cover the subset, not the full nav.
             partial = bool(getattr(args, "page", None) or getattr(args, "section", None))

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/src/mkdocs_to_confluence/emitter/xhtml.py

@@ -422,15 +422,19 @@ def _emit_task_item(item: ListItem) -> str:
 
 
 def _emit_list_item(item: ListItem) -> str:
-    if any(isinstance(c, _LIST_BLOCK_TYPES) for c in item.children):
-        # Loose list item: children are block nodes (e.g. nested list or paragraph).
-        inner = emit(item.children)
-        return f"  <li>{inner.strip()}</li>\n"
-    # Tight list item: children are inline nodes.  Confluence requires a <p>
-    # wrapper inside <li> for structured inline macros (e.g. <ac:link>) to
-    # render — without it they are silently stripped by the storage parser.
-    inner = _emit_inlines(item.children)
-    return f"  <li><p>{inner}</p></li>\n"
+    first_block = next(
+        (i for i, c in enumerate(item.children) if isinstance(c, _LIST_BLOCK_TYPES)), None
+    )
+    if first_block is None:
+        # All inline — standard tight rendering.
+        inner = _emit_inlines(item.children)
+        return f"  <li><p>{inner}</p></li>\n"
+    # Mixed: inline prefix (if any) wrapped in <p>, followed by block children.
+    parts: list[str] = []
+    if first_block > 0:
+        parts.append(f"<p>{_emit_inlines(item.children[:first_block])}</p>\n")
+    parts.append(emit(item.children[first_block:]))
+    return f"  <li>{''.join(parts).strip()}</li>\n"
 
 
 def _emit_table(node: Table) -> str:

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/src/mkdocs_to_confluence/parser/markdown.py

@@ -158,6 +158,7 @@ class _BlockQuoteToken:
 class _ListItemData:
     text: str
     task: bool | None = None  # None=regular, True=checked, False=unchecked
+    sub_tokens: list[_Token] = field(default_factory=list)
 
 
 @dataclass
@@ -501,7 +502,8 @@ def _tokenize(text: str) -> list[_Token]:
                     task = task_m.group("state").lower() == "x"
                     item_text = task_m.group("rest")
                 i += 1
-                # Collect continuation lines (non-blank, non-list) into this item.
+                # Collect continuation and indented sub-list lines.
+                sub_lines: list[str] = []
                 while i < len(lines) and lines[i].strip():
                     cont = lines[i]
                     bullet_m = _BULLET_RE.match(cont)
@@ -510,9 +512,18 @@ def _tokenize(text: str) -> list[_Token]:
                         ordered_m2 and not ordered_m2.group("indent")
                     ):
                         break
-                    item_text = item_text.rstrip() + " " + cont.strip()
+                    if (bullet_m and bullet_m.group("indent")) or (
+                        ordered_m2 and ordered_m2.group("indent")
+                    ) or sub_lines:
+                        sub_lines.append(cont)
+                    else:
+                        item_text = item_text.rstrip() + " " + cont.strip()
                     i += 1
-                list_items.append(_ListItemData(text=item_text, task=task))
+                _sub: list[_Token] = []
+                if sub_lines:
+                    _ind = min(len(ln) - len(ln.lstrip()) for ln in sub_lines if ln.strip())
+                    _sub = _tokenize("\n".join(ln[_ind:] for ln in sub_lines))
+                list_items.append(_ListItemData(text=item_text, task=task, sub_tokens=_sub))
             tokens.append(_BulletListToken(items=list_items))
             continue
 
@@ -537,7 +548,8 @@ def _tokenize(text: str) -> list[_Token]:
                     break
                 item_text = om.group("text")
                 i += 1
-                # Collect continuation lines (non-blank, non-list) into this item.
+                # Collect continuation and indented sub-list lines.
+                sub_lines_ord: list[str] = []
                 while i < len(lines) and lines[i].strip():
                     cont = lines[i]
                     ordered_m3 = _ORDERED_RE.match(cont)
@@ -546,9 +558,18 @@ def _tokenize(text: str) -> list[_Token]:
                         bullet_m2 and not bullet_m2.group("indent")
                     ):
                         break
-                    item_text = item_text.rstrip() + " " + cont.strip()
+                    if (ordered_m3 and ordered_m3.group("indent")) or (
+                        bullet_m2 and bullet_m2.group("indent")
+                    ) or sub_lines_ord:
+                        sub_lines_ord.append(cont)
+                    else:
+                        item_text = item_text.rstrip() + " " + cont.strip()
                     i += 1
-                ord_items.append(_ListItemData(text=item_text))
+                _sub_ord: list[_Token] = []
+                if sub_lines_ord:
+                    _ind_ord = min(len(ln) - len(ln.lstrip()) for ln in sub_lines_ord if ln.strip())
+                    _sub_ord = _tokenize("\n".join(ln[_ind_ord:] for ln in sub_lines_ord))
+                ord_items.append(_ListItemData(text=item_text, sub_tokens=_sub_ord))
             tokens.append(_OrderedListToken(start=start, items=ord_items))
             continue
 
@@ -1030,6 +1051,32 @@ class _OpenSection:
     children: list[IRNode] = field(default_factory=list)
 
 
+def _build_sub_list_nodes(tokens: list[_Token], fn_map: dict[str, int] | None) -> tuple[IRNode, ...]:
+    """Recursively convert sub-list tokens (from indented continuation) to IR nodes."""
+    nodes: list[IRNode] = []
+    for token in tokens:
+        if isinstance(token, _BulletListToken):
+            items = tuple(
+                ListItem(
+                    children=_parse_inline(item.text, fn_map=fn_map)
+                    + _build_sub_list_nodes(item.sub_tokens, fn_map),
+                    task=item.task,
+                )
+                for item in token.items
+            )
+            nodes.append(BulletList(items=items))
+        elif isinstance(token, _OrderedListToken):
+            items = tuple(
+                ListItem(
+                    children=_parse_inline(item.text, fn_map=fn_map)
+                    + _build_sub_list_nodes(item.sub_tokens, fn_map),
+                )
+                for item in token.items
+            )
+            nodes.append(OrderedList(items=items, start=token.start))
+    return tuple(nodes)
+
+
 def _build_tree(
     tokens: list[_Token],
     fn_map: dict[str, int] | None = None,
@@ -1101,14 +1148,21 @@ def _build_tree(
 
         elif isinstance(token, _BulletListToken):
             items = tuple(
-                ListItem(children=_parse_inline(item.text, fn_map=_fn), task=item.task)
+                ListItem(
+                    children=_parse_inline(item.text, fn_map=_fn)
+                    + _build_sub_list_nodes(item.sub_tokens, _fn),
+                    task=item.task,
+                )
                 for item in token.items
             )
             _append_content(BulletList(items=items), stack, root)
 
         elif isinstance(token, _OrderedListToken):
             items = tuple(
-                ListItem(children=_parse_inline(item.text, fn_map=_fn))
+                ListItem(
+                    children=_parse_inline(item.text, fn_map=_fn)
+                    + _build_sub_list_nodes(item.sub_tokens, _fn),
+                )
                 for item in token.items
             )
             _append_content(OrderedList(items=items, start=token.start), stack, root)

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/src/mkdocs_to_confluence/publisher/pipeline.py

@@ -238,15 +238,20 @@ def plan_publish(
     *,
     space_id: str,
     quiet: bool = False,
+    full_nav_nodes: list[NavNode] | None = None,
 ) -> list[PageAction]:
     """Build a publish plan for the entire nav tree.
 
     Section nodes become native Confluence folders so the hierarchy is
     preserved visually.  The actual find-or-create for folders is deferred
     to execute time once parent folder IDs are known.
+
+    ``full_nav_nodes``, when provided, is used to build the link map so that
+    cross-section internal links resolve correctly even when publishing only a
+    subset of the nav (e.g. ``--section``).
     """
     actions: list[PageAction] = []
-    link_map = build_link_map(nav_nodes)
+    link_map = build_link_map(full_nav_nodes if full_nav_nodes is not None else nav_nodes)
     if not quiet:
         print("Planning...")
     _plan_nodes(nav_nodes, client, config, space_id, conf_config.parent_page_id, False, actions, link_map, quiet=quiet)

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/tests/test_emitter.py

@@ -235,6 +235,32 @@ class TestListEmitters:
         assert "<ul>" in out
         assert "<ac:task-list>" not in out
 
+    def test_nested_bullet_list(self) -> None:
+        nested = BulletList(items=(ListItem((TextNode("child"),)),))
+        items = (ListItem((TextNode("parent"), nested)),)
+        out = emit((BulletList(items=items),))
+        assert out.count("<ul>") == 2
+        assert out.count("</ul>") == 2
+        assert "<p>parent</p>" in out
+        assert "<p>child</p>" in out
+
+    def test_nested_ordered_list(self) -> None:
+        nested = OrderedList(items=(ListItem((TextNode("sub"),)),))
+        items = (ListItem((TextNode("top"), nested)),)
+        out = emit((OrderedList(items=items),))
+        assert "<ol>" in out
+        assert "<ul>" not in out
+        assert "<p>top</p>" in out
+        assert "<p>sub</p>" in out
+
+    def test_nested_list_no_inline_prefix(self) -> None:
+        """A list item with only a nested sub-list (no inline text) renders cleanly."""
+        nested = BulletList(items=(ListItem((TextNode("only child"),)),))
+        items = (ListItem((nested,)),)
+        out = emit((BulletList(items=items),))
+        assert out.count("<ul>") == 2
+        assert "<p>only child</p>" in out
+
 
 class TestHorizontalRule:
     def test_hr(self) -> None:

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/tests/test_internallinks.py

@@ -364,3 +364,61 @@ def test_unresolved_md_link_with_anchor_degrades_to_label():
     xhtml = emit((Paragraph(children=(link,)),))
     assert "Hello World" in xhtml
     assert "hello-worl.md" not in xhtml
+
+
+def test_link_inside_admonition_resolves():
+    """A relative .md link inside an admonition body must resolve to ac:link.
+
+    Regression: links inside admonitions were reported as showing raw label
+    text instead of Confluence hyperlinks when the target page was in a
+    different section (cross-section link).
+    """
+    from mkdocs_to_confluence.emitter.xhtml import emit
+    from mkdocs_to_confluence.parser.markdown import parse
+
+    nav = _make_nav([("proposals/2026/authentication-procedures.md", "Auth Procedures")])
+    link_map = build_link_map(nav)
+    current_path = "architecture/identity/keycloak.md"
+
+    md = '!!! info "Related document"\n    See [Auth Procedures](../../proposals/2026/authentication-procedures.md).\n'
+    nodes = parse(md)
+    resolved = resolve_internal_links(nodes, link_map, current_path)
+    xhtml = emit(resolved)
+
+    assert 'ri:content-title="Auth Procedures"' in xhtml
+    assert "authentication-procedures.md" not in xhtml
+
+
+def test_cross_section_link_resolves_when_full_nav_used():
+    """build_link_map must include all nav pages so cross-section links resolve.
+
+    The root cause of the admonition link bug: when publishing with --section,
+    the link_map was built from the section subtree only.  Cross-section targets
+    were missing and links degraded to label text.
+    """
+    from mkdocs_to_confluence.emitter.xhtml import emit
+    from mkdocs_to_confluence.parser.markdown import parse
+
+    # Two separate sections
+    full_nav = _make_nav([
+        ("section-a/page.md", "Page A"),
+        ("section-b/target.md", "Target Page"),
+    ])
+    section_a_nav = _make_nav([("section-a/page.md", "Page A")])
+
+    link_map_full = build_link_map(full_nav)
+    link_map_section_only = build_link_map(section_a_nav)
+
+    md = "See [Target Page](../section-b/target.md).\n"
+    nodes = parse(md)
+
+    # With full nav: link resolves
+    resolved_full = resolve_internal_links(nodes, link_map_full, "section-a/page.md")
+    xhtml_full = emit(resolved_full)
+    assert 'ri:content-title="Target Page"' in xhtml_full
+
+    # With section-only nav: link degrades to label text
+    resolved_section = resolve_internal_links(nodes, link_map_section_only, "section-a/page.md")
+    xhtml_section = emit(resolved_section)
+    assert "Target Page" in xhtml_section
+    assert "ri:content-title" not in xhtml_section

{mkdocs2confluence-0.10.0 → mkdocs2confluence-0.10.2}/tests/test_parser.py

@@ -1021,6 +1021,49 @@ class TestListParsing:
         )
         assert "Continuation" in item_text or "First point" in item_text
 
+    def test_nested_bullet_list(self) -> None:
+        md = "- item 1\n  - nested 1\n  - nested 2\n- item 2\n"
+        nodes = parse(md)
+        bl = first(nodes, BulletList)
+        assert isinstance(bl, BulletList)
+        assert len(bl.items) == 2
+        # First item must have a nested BulletList as a child.
+        nested = next((c for c in bl.items[0].children if isinstance(c, BulletList)), None)
+        assert nested is not None, "expected nested BulletList in first item"
+        assert len(nested.items) == 2
+        assert nested.items[0].children[0].text == "nested 1"  # type: ignore[union-attr]
+        assert nested.items[1].children[0].text == "nested 2"  # type: ignore[union-attr]
+
+    def test_nested_ordered_list(self) -> None:
+        md = "1. first\n   1. sub one\n   2. sub two\n2. second\n"
+        nodes = parse(md)
+        ol = first(nodes, OrderedList)
+        assert isinstance(ol, OrderedList)
+        nested = next((c for c in ol.items[0].children if isinstance(c, OrderedList)), None)
+        assert nested is not None, "expected nested OrderedList in first item"
+        assert len(nested.items) == 2
+
+    def test_deeply_nested_bullet_list(self) -> None:
+        md = "- a\n  - b\n    - c\n"
+        nodes = parse(md)
+        bl = first(nodes, BulletList)
+        assert isinstance(bl, BulletList)
+        level2 = next((c for c in bl.items[0].children if isinstance(c, BulletList)), None)
+        assert level2 is not None
+        level3 = next((c for c in level2.items[0].children if isinstance(c, BulletList)), None)
+        assert level3 is not None
+        assert level3.items[0].children[0].text == "c"  # type: ignore[union-attr]
+
+    def test_mixed_nested_list(self) -> None:
+        """Bullet list item containing an ordered sub-list."""
+        md = "- item\n  1. sub one\n  2. sub two\n"
+        nodes = parse(md)
+        bl = first(nodes, BulletList)
+        assert isinstance(bl, BulletList)
+        nested_ol = next((c for c in bl.items[0].children if isinstance(c, OrderedList)), None)
+        assert nested_ol is not None
+        assert len(nested_ol.items) == 2
+
 
 # ── Definition list parsing ───────────────────────────────────────────────────