conjira-cli 0.2.3__tar.gz → 0.2.5__tar.gz

{conjira_cli-0.2.3/src/conjira_cli.egg-info → conjira_cli-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conjira-cli
-Version: 0.2.3
+Version: 0.2.5
 Summary: Unofficial agent-friendly CLI for self-hosted Confluence and Jira
 Author: quanttraderkim
 License-Expression: MIT
@@ -338,6 +338,12 @@ Replace one named section on an existing Confluence page:
 conjira --env-file ./local/agent.env replace-section --allow-write --page-id 100002 --heading "Rollout plan" --section-markdown-file ./notes/rollout.md
 ```
 
+Insert new content immediately after a named heading:
+
+```bash
+conjira --env-file ./local/agent.env insert-after-heading --dry-run --page-id 100002 --heading "Rollout plan" --insert-markdown-file ./notes/rollout-intro.md
+```
+
 Move an existing Confluence page under a different parent page:
 
 ```bash

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/README.md

@@ -309,6 +309,12 @@ Replace one named section on an existing Confluence page:
 conjira --env-file ./local/agent.env replace-section --allow-write --page-id 100002 --heading "Rollout plan" --section-markdown-file ./notes/rollout.md
 ```
 
+Insert new content immediately after a named heading:
+
+```bash
+conjira --env-file ./local/agent.env insert-after-heading --dry-run --page-id 100002 --heading "Rollout plan" --insert-markdown-file ./notes/rollout-intro.md
+```
+
 Move an existing Confluence page under a different parent page:
 
 ```bash

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/pyproject.toml

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

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/src/conjira_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/src/conjira_cli/cli.py

@@ -23,7 +23,11 @@ from conjira_cli.config import (
 from conjira_cli.inline_comments import render_inline_comment_summary_markdown
 from conjira_cli.markdown_export import MarkdownExporter
 from conjira_cli.markdown_import import markdown_to_storage_html
-from conjira_cli.section_edit import SectionEditError, replace_section_html
+from conjira_cli.section_edit import (
+    SectionEditError,
+    insert_after_heading_html,
+    replace_section_html,
+)
 from conjira_cli.tree_export import export_page_tree, sanitize_path_component
 
 _JIRA_SUMMARY_FIELDS = [
@@ -402,6 +406,22 @@ def _build_parser() -> argparse.ArgumentParser:
     replace_section_body_group.add_argument("--section-markdown")
     replace_section_body_group.add_argument("--section-markdown-file")
 
+    insert_after_heading = subparsers.add_parser(
+        "insert-after-heading",
+        help="Insert content immediately after a specific Confluence heading",
+    )
+    insert_after_heading.add_argument("--page-id", required=True)
+    insert_after_heading.add_argument("--heading", required=True)
+    insert_after_heading.add_argument("--allow-write", action="store_true")
+    insert_after_heading.add_argument("--dry-run", action="store_true")
+    insert_after_heading_body_group = insert_after_heading.add_mutually_exclusive_group(
+        required=True
+    )
+    insert_after_heading_body_group.add_argument("--insert-html")
+    insert_after_heading_body_group.add_argument("--insert-file")
+    insert_after_heading_body_group.add_argument("--insert-markdown")
+    insert_after_heading_body_group.add_argument("--insert-markdown-file")
+
     move_page = subparsers.add_parser(
         "move-page",
         help="Move an existing Confluence page under a different parent page",
@@ -634,6 +654,31 @@ def _confluence_replace_section_preview(
     }
 
 
+def _confluence_insert_after_heading_preview(
+    *,
+    page: Dict[str, Any],
+    heading: str,
+    result: Any,
+    body_source: str,
+) -> Dict[str, Any]:
+    current_summary = ConfluenceClient.summarize_page(page)
+    return {
+        "dry_run": True,
+        "product": "confluence",
+        "action": "insert-after-heading",
+        "page_id": current_summary.get("id"),
+        "space_key": current_summary.get("space_key"),
+        "source_url": current_summary.get("webui_url"),
+        "heading": heading,
+        "matched_heading": result.matched_heading,
+        "heading_level": result.heading_level,
+        "body_source": body_source,
+        "inserted_after_heading": True,
+        "inserted_block_preview": _preview_html(result.inserted_html),
+        "resulting_body_preview": _preview_html(result.updated_body_html),
+    }
+
+
 def _confluence_move_page_preview(
     *,
     page: Dict[str, Any],
@@ -819,6 +864,11 @@ def _guidance_for_config_error(message: str) -> list[str]:
             "Check that the heading text exists exactly once on the live Confluence page before retrying replace-section.",
             "For the first iteration, replace-section is safest on text-first pages with clear heading structure.",
         ]
+    if "insert-after-heading target heading" in lowered:
+        return [
+            "Check that the heading text exists exactly once on the live Confluence page before retrying insert-after-heading.",
+            "insert-after-heading is safest on text-first pages with clear heading structure and a stable target heading.",
+        ]
     if "move-page requires different" in lowered:
         return [
             "Choose a different parent page before retrying move-page.",
@@ -1190,6 +1240,51 @@ def _handle_confluence(args: argparse.Namespace) -> Dict[str, Any]:
         payload["heading"] = args.heading
         payload["matched_heading"] = replacement.matched_heading
         return payload
+    if args.command == "insert-after-heading":
+        _require_write_intent(args.allow_write, args.dry_run)
+        _assert_confluence_update_allowed(
+            page_id=args.page_id,
+            allowed_page_ids=settings.allowed_page_ids,
+        )
+        inserted_html = _read_confluence_body_arg(
+            args.insert_html,
+            args.insert_file,
+            args.insert_markdown,
+            args.insert_markdown_file,
+            mermaid_macro_name=settings.mermaid_macro_name,
+        )
+        page = client.get_page(args.page_id, expand="body.storage,version,space")
+        current_body = (((page.get("body") or {}).get("storage") or {}).get("value")) or ""
+        try:
+            insertion = insert_after_heading_html(
+                current_body,
+                heading=args.heading,
+                inserted_html=inserted_html,
+            )
+        except SectionEditError as exc:
+            raise ConfigError(str(exc)) from exc
+        body_source = _confluence_body_source(
+            raw_html=args.insert_html,
+            html_file=args.insert_file,
+            raw_markdown=args.insert_markdown,
+            markdown_file=args.insert_markdown_file,
+        )
+        if args.dry_run:
+            return _confluence_insert_after_heading_preview(
+                page=page,
+                heading=args.heading,
+                result=insertion,
+                body_source=body_source or "unknown",
+            )
+        updated = client.update_page_from_snapshot(
+            page,
+            new_body_html=insertion.updated_body_html,
+        )
+        payload = client.summarize_page(updated)
+        payload["action"] = "insert-after-heading"
+        payload["heading"] = args.heading
+        payload["matched_heading"] = insertion.matched_heading
+        return payload
     if args.command == "move-page":
         _require_write_intent(args.allow_write, args.dry_run)
         _assert_confluence_update_allowed(

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/src/conjira_cli/client.py

@@ -5,6 +5,7 @@ import time
 import urllib.error
 import urllib.parse
 import urllib.request
+import xml.etree.ElementTree as ET
 from typing import Any, Dict, Iterable, Optional
 
 from conjira_cli.inline_comments import build_inline_comment_summary
@@ -31,6 +32,28 @@ class JiraError(AtlassianError):
     pass
 
 
+def validate_storage_html(body_html: str) -> None:
+    """Check that *body_html* is well-formed XHTML before sending to Confluence.
+
+    Raises :class:`ConfluenceError` with a descriptive message if parsing
+    fails, giving the caller a chance to fix the content instead of getting
+    a cryptic 400 from the server.
+    """
+    wrapped = (
+        '<root xmlns:ac="urn:ac" xmlns:ri="urn:ri"'
+        ' xmlns:atlassian="urn:atlassian">'
+        + body_html
+        + "</root>"
+    )
+    try:
+        ET.fromstring(wrapped)
+    except ET.ParseError as exc:
+        raise ConfluenceError(
+            f"Body HTML is not well-formed XHTML — Confluence will reject it. "
+            f"Detail: {exc}",
+        ) from exc
+
+
 class BaseAtlassianClient:
     product_name = "Atlassian"
     error_cls = AtlassianError
@@ -83,8 +106,15 @@ class BaseAtlassianClient:
                 raw = response.read().decode("utf-8")
                 if not raw:
                     return None
-                if "application/json" in response.headers.get("Content-Type", ""):
+                content_type = response.headers.get("Content-Type", "")
+                if "application/json" in content_type:
                     return json.loads(raw)
+                stripped = raw.lstrip()
+                if stripped.startswith("{") or stripped.startswith("["):
+                    try:
+                        return json.loads(raw)
+                    except json.JSONDecodeError:
+                        pass
                 return raw
         except urllib.error.HTTPError as exc:
             raw = exc.read().decode("utf-8", errors="replace")
@@ -168,6 +198,7 @@ class ConfluenceClient(BaseAtlassianClient):
         body_html: str,
         parent_id: Optional[str] = None,
     ) -> Dict[str, Any]:
+        validate_storage_html(body_html)
         payload: Dict[str, Any] = {
             "type": "page",
             "title": title,
@@ -215,6 +246,8 @@ class ConfluenceClient(BaseAtlassianClient):
         if append_html:
             updated_body += append_html
 
+        validate_storage_html(updated_body)
+
         payload = {
             "id": current["id"],
             "type": current["type"],

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/src/conjira_cli/markdown_export.py

@@ -470,16 +470,27 @@ class MarkdownExporter:
             child_name = _local_name(child.tag)
             if child_name in {"ul", "ol"}:
                 list_text = self._render_block(child, indent=0).strip().replace("\n", "<br>")
+                # Escape unescaped pipes BEFORE joining so nested content
+                # doesn't break the outer table column boundaries.
+                # Use negative lookbehind to avoid double-escaping pipes
+                # that were already escaped by deeper recursion.
+                list_text = re.sub(r"(?<!\\)\|", r"\\|", list_text)
                 pieces.append(list_text)
             elif child_name == "table":
                 table_text = self._render_table(child).replace("\n", "<br>")
+                # Escape unescaped pipes from the nested table so they
+                # don't create spurious columns in the parent table row.
+                table_text = re.sub(r"(?<!\\)\|", r"\\|", table_text)
                 pieces.append(table_text)
             else:
                 pieces.append(self._render_inline(child))
             if child.tail and _collapse_inline(child.tail):
                 pieces.append(_collapse_inline(child.tail))
         joined = _join_inline_pieces(pieces)
-        joined = joined.replace("|", "\\|")
+        # Escape any remaining unescaped pipes from inline content.
+        # Use a negative lookbehind to avoid double-escaping pipes that
+        # were already escaped above.
+        joined = re.sub(r"(?<!\\)\|", r"\\|", joined)
         joined = joined.replace("\n", "<br>")
         joined = re.sub(r"\s{2,}", " ", joined)
         joined = re.sub(r"^(<br>\s*)+$", "", joined)

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/src/conjira_cli/markdown_import.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import html
 import os
 import re
+import xml.etree.ElementTree as ET
 from typing import Optional
 
 
@@ -39,7 +40,33 @@ def markdown_to_storage_html(
     markdown = _strip_frontmatter(markdown).replace("\r\n", "\n").replace("\r", "\n")
     lines = markdown.split("\n")
     html_parts, _ = _parse_blocks(lines, 0, mermaid_macro_name=mermaid_macro_name)
-    return "".join(html_parts).strip()
+    result = "".join(html_parts).strip()
+    return _ensure_xhtml_self_closing(result)
+
+
+# Tags that must be self-closing in Confluence XHTML Storage Format
+_VOID_TAGS = {"br", "hr", "img"}
+_VOID_TAG_RE = re.compile(
+    r"<(" + "|".join(_VOID_TAGS) + r")((?:\s[^>]*?)?)(\s*/?)>",
+    re.IGNORECASE,
+)
+
+
+def _ensure_xhtml_self_closing(html_str: str) -> str:
+    """Normalise void HTML tags to XHTML self-closing form.
+
+    Confluence Storage Format requires strict XHTML: ``<br />`` not ``<br>``.
+    Handles ``<br>``, ``<br/>``, ``<br />``, and variants with attributes.
+    """
+    def _fix(m: re.Match[str]) -> str:
+        tag = m.group(1)
+        attrs = (m.group(2) or "").rstrip()
+        # Strip any trailing slash already present in attrs
+        if attrs.endswith("/"):
+            attrs = attrs[:-1].rstrip()
+        return f"<{tag}{attrs} />"
+
+    return _VOID_TAG_RE.sub(_fix, html_str)
 
 
 def _strip_frontmatter(markdown: str) -> str:
@@ -345,19 +372,58 @@ def _parse_table(lines: list[str], start: int) -> tuple[str, int]:
     if has_header:
         parts.append(
             "<tr>{0}</tr>".format(
-                "".join("<th>{0}</th>".format(_render_inline(cell)) for cell in rows[0])
+                "".join("<th>{0}</th>".format(_render_table_cell(cell)) for cell in rows[0])
             )
         )
     for row in body_rows:
         parts.append(
             "<tr>{0}</tr>".format(
-                "".join("<td>{0}</td>".format(_render_inline(cell)) for cell in row)
+                "".join("<td>{0}</td>".format(_render_table_cell(cell)) for cell in row)
             )
         )
     parts.append("</tbody></table>")
     return "".join(parts), i
 
 
+_CELL_HTML_BLOCK_PREFIX_RE = re.compile(
+    r"^<(ul|ol|p|div|table|blockquote|h[1-6]|ac:[\w-]+|ri:[\w-]+|atlassian:[\w-]+)\b",
+    re.IGNORECASE,
+)
+_CELL_XML_WRAPPER_PREFIX = (
+    '<root xmlns:ac="urn:ac" xmlns:ri="urn:ri" xmlns:atlassian="urn:atlassian">'
+)
+
+
+def _render_table_cell(cell: str) -> str:
+    """Render a markdown table cell.
+
+    Standard markdown tables only support inline content per cell, but
+    Confluence cells frequently need nested structures (``<ul><li>``,
+    ``<p>``, etc.). When the cell content is a well-formed HTML block,
+    we pass it through unchanged so users can hand-author rich cells
+    without leaving the markdown pipeline.
+
+    Pass-through covers the entire cell: any trailing content after the
+    HTML block is emitted verbatim and not re-rendered as markdown.
+    """
+    stripped = cell.strip()
+    if (
+        stripped.startswith("<")
+        and _CELL_HTML_BLOCK_PREFIX_RE.match(stripped)
+        and _is_well_formed_xhtml(stripped)
+    ):
+        return stripped
+    return _render_inline(cell)
+
+
+def _is_well_formed_xhtml(fragment: str) -> bool:
+    try:
+        ET.fromstring(_CELL_XML_WRAPPER_PREFIX + fragment + "</root>")
+    except ET.ParseError:
+        return False
+    return True
+
+
 def _split_table_row(line: str) -> list[str]:
     stripped = line.strip()
     if stripped.startswith("|"):

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/src/conjira_cli/section_edit.py

@@ -27,6 +27,15 @@ class SectionReplacementResult:
     updated_body_html: str
 
 
+@dataclass
+class HeadingInsertionResult:
+    heading: str
+    matched_heading: str
+    heading_level: int
+    inserted_html: str
+    updated_body_html: str
+
+
 def replace_section_html(
     body_html: str,
     *,
@@ -35,29 +44,11 @@ def replace_section_html(
 ) -> SectionReplacementResult:
     root = _parse_fragment(body_html)
     children = list(root)
-    normalized_target = _normalize_heading(heading)
-
-    matches: list[tuple[int, ET.Element, int]] = []
-    for index, child in enumerate(children):
-        heading_level = _heading_level(child)
-        if heading_level is None:
-            continue
-        rendered_heading = _element_text(child)
-        if _normalize_heading(rendered_heading) == normalized_target:
-            matches.append((index, child, heading_level))
-
-    if not matches:
-        raise SectionEditError(
-            'replace-section target heading "{0}" was not found.'.format(heading)
-        )
-    if len(matches) > 1:
-        raise SectionEditError(
-            'replace-section target heading "{0}" is ambiguous because it appears multiple times.'.format(
-                heading
-            )
-        )
-
-    match_index, match_elem, match_level = matches[0]
+    match_index, match_elem, match_level = _find_unique_heading(
+        children,
+        heading=heading,
+        action_name="replace-section",
+    )
     end_index = len(children)
     for index in range(match_index + 1, len(children)):
         next_level = _heading_level(children[index])
@@ -87,6 +78,36 @@ def replace_section_html(
     )
 
 
+def insert_after_heading_html(
+    body_html: str,
+    *,
+    heading: str,
+    inserted_html: str,
+) -> HeadingInsertionResult:
+    root = _parse_fragment(body_html)
+    children = list(root)
+    match_index, match_elem, match_level = _find_unique_heading(
+        children,
+        heading=heading,
+        action_name="insert-after-heading",
+    )
+
+    new_root = _parse_fragment(inserted_html)
+    new_children = [copy.deepcopy(child) for child in list(new_root)]
+
+    insert_at = match_index + 1
+    for offset, child in enumerate(new_children):
+        root.insert(insert_at + offset, child)
+
+    return HeadingInsertionResult(
+        heading=heading,
+        matched_heading=_element_text(match_elem),
+        heading_level=match_level,
+        inserted_html=_serialize_elements(new_children),
+        updated_body_html=_serialize_root(root),
+    )
+
+
 def _parse_fragment(fragment_html: str) -> ET.Element:
     wrapped = _WRAPPED_ROOT_PREFIX + fragment_html + "</root>"
     try:
@@ -103,6 +124,36 @@ def _serialize_elements(elements: list[ET.Element]) -> str:
     return "".join(ET.tostring(element, encoding="unicode") for element in elements).strip()
 
 
+def _find_unique_heading(
+    children: list[ET.Element],
+    *,
+    heading: str,
+    action_name: str,
+) -> tuple[int, ET.Element, int]:
+    normalized_target = _normalize_heading(heading)
+    matches: list[tuple[int, ET.Element, int]] = []
+    for index, child in enumerate(children):
+        heading_level = _heading_level(child)
+        if heading_level is None:
+            continue
+        rendered_heading = _element_text(child)
+        if _normalize_heading(rendered_heading) == normalized_target:
+            matches.append((index, child, heading_level))
+
+    if not matches:
+        raise SectionEditError(
+            '{0} target heading "{1}" was not found.'.format(action_name, heading)
+        )
+    if len(matches) > 1:
+        raise SectionEditError(
+            '{0} target heading "{1}" is ambiguous because it appears multiple times.'.format(
+                action_name,
+                heading,
+            )
+        )
+    return matches[0]
+
+
 def _local_name(tag: str) -> str:
     if "}" in tag:
         return tag.split("}", 1)[1]

{conjira_cli-0.2.3 → conjira_cli-0.2.5/src/conjira_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conjira-cli
-Version: 0.2.3
+Version: 0.2.5
 Summary: Unofficial agent-friendly CLI for self-hosted Confluence and Jira
 Author: quanttraderkim
 License-Expression: MIT
@@ -338,6 +338,12 @@ Replace one named section on an existing Confluence page:
 conjira --env-file ./local/agent.env replace-section --allow-write --page-id 100002 --heading "Rollout plan" --section-markdown-file ./notes/rollout.md
 ```
 
+Insert new content immediately after a named heading:
+
+```bash
+conjira --env-file ./local/agent.env insert-after-heading --dry-run --page-id 100002 --heading "Rollout plan" --insert-markdown-file ./notes/rollout-intro.md
+```
+
 Move an existing Confluence page under a different parent page:
 
 ```bash

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/tests/test_cli.py

@@ -570,6 +570,141 @@ class CliTests(unittest.TestCase):
         self.assertEqual(mock_update_page.call_args.args[0]["id"], "12345")
         self.assertIn("<p>Replacement</p>", mock_update_page.call_args.kwargs["new_body_html"])
 
+    def test_handle_confluence_insert_after_heading_dry_run_returns_preview(self) -> None:
+        args = SimpleNamespace(
+            command="insert-after-heading",
+            base_url=None,
+            token=None,
+            token_file=None,
+            token_keychain_service=None,
+            token_keychain_account=None,
+            timeout=None,
+            env_file=None,
+            page_id="12345",
+            heading="Install",
+            allow_write=False,
+            dry_run=True,
+            insert_html=None,
+            insert_file=None,
+            insert_markdown="Prepended install note",
+            insert_markdown_file=None,
+        )
+        settings = ConfluenceSettings(
+            base_url="https://confluence.example.com",
+            token="token",
+            timeout_seconds=30,
+        )
+        page = {
+            "id": "12345",
+            "type": "page",
+            "title": "Guide",
+            "space": {"key": "DOCS"},
+            "version": {"number": 7},
+            "body": {
+                "storage": {
+                    "value": (
+                        "<h1>Guide</h1>"
+                        "<h2>Install</h2>"
+                        "<p>Old step</p>"
+                        "<h2>Usage</h2>"
+                        "<p>Run command</p>"
+                    )
+                }
+            },
+            "_links": {
+                "base": "https://confluence.example.com",
+                "webui": "/pages/viewpage.action?pageId=12345",
+            },
+        }
+
+        with mock.patch("conjira_cli.cli.build_confluence_settings", return_value=settings), mock.patch(
+            "conjira_cli.cli.ConfluenceClient.get_page",
+            return_value=page,
+        ) as mock_get_page, mock.patch(
+            "conjira_cli.cli.ConfluenceClient.update_page_from_snapshot"
+        ) as mock_update_page:
+            payload = _handle_confluence(args)
+
+        self.assertTrue(payload["dry_run"])
+        self.assertEqual(payload["action"], "insert-after-heading")
+        self.assertEqual(payload["page_id"], "12345")
+        self.assertEqual(payload["heading"], "Install")
+        self.assertEqual(payload["matched_heading"], "Install")
+        self.assertEqual(payload["body_source"], "markdown")
+        self.assertIn("Prepended install note", payload["inserted_block_preview"])
+        mock_get_page.assert_called_once_with("12345", expand="body.storage,version,space")
+        mock_update_page.assert_not_called()
+
+    def test_handle_confluence_insert_after_heading_write_updates_page(self) -> None:
+        args = SimpleNamespace(
+            command="insert-after-heading",
+            base_url=None,
+            token=None,
+            token_file=None,
+            token_keychain_service=None,
+            token_keychain_account=None,
+            timeout=None,
+            env_file=None,
+            page_id="12345",
+            heading="Install",
+            allow_write=True,
+            dry_run=False,
+            insert_html="<p>Inserted</p>",
+            insert_file=None,
+            insert_markdown=None,
+            insert_markdown_file=None,
+        )
+        settings = ConfluenceSettings(
+            base_url="https://confluence.example.com",
+            token="token",
+            timeout_seconds=30,
+        )
+        page = {
+            "id": "12345",
+            "type": "page",
+            "title": "Guide",
+            "space": {"key": "DOCS"},
+            "version": {"number": 7},
+            "body": {
+                "storage": {
+                    "value": "<h2>Install</h2><p>Old step</p><h2>Usage</h2><p>Run command</p>"
+                }
+            },
+            "_links": {
+                "base": "https://confluence.example.com",
+                "webui": "/pages/viewpage.action?pageId=12345",
+            },
+        }
+        updated_summary = {
+            "id": "12345",
+            "type": "page",
+            "status": "current",
+            "title": "Guide",
+            "space": {"key": "DOCS"},
+            "version": {"number": 8},
+            "_links": {
+                "base": "https://confluence.example.com",
+                "webui": "/pages/viewpage.action?pageId=12345",
+            },
+        }
+
+        with mock.patch("conjira_cli.cli.build_confluence_settings", return_value=settings), mock.patch(
+            "conjira_cli.cli.ConfluenceClient.get_page",
+            return_value=page,
+        ) as mock_get_page, mock.patch(
+            "conjira_cli.cli.ConfluenceClient.update_page_from_snapshot",
+            return_value=updated_summary,
+        ) as mock_update_page:
+            payload = _handle_confluence(args)
+
+        self.assertEqual(payload["action"], "insert-after-heading")
+        self.assertEqual(payload["heading"], "Install")
+        self.assertEqual(payload["matched_heading"], "Install")
+        mock_get_page.assert_called_once_with("12345", expand="body.storage,version,space")
+        mock_update_page.assert_called_once()
+        self.assertEqual(mock_update_page.call_args.args[0]["id"], "12345")
+        self.assertIn("<h2>Install</h2><p>Inserted</p><p>Old step</p>", mock_update_page.call_args.kwargs["new_body_html"])
+
     def test_handle_confluence_move_page_dry_run_returns_preview(self) -> None:
         args = SimpleNamespace(
             command="move-page",
@@ -691,6 +826,14 @@ class CliTests(unittest.TestCase):
         self.assertEqual(payload["error_type"], "ConfigError")
         self.assertTrue(any("heading" in item.lower() for item in payload["guidance"]))
 
+    def test_build_error_payload_adds_insert_after_heading_guidance(self) -> None:
+        payload = _build_error_payload(
+            ConfigError('insert-after-heading target heading "Install" was not found.')
+        )
+
+        self.assertEqual(payload["error_type"], "ConfigError")
+        self.assertTrue(any("insert-after-heading" in item.lower() for item in payload["guidance"]))
+
     def test_build_error_payload_adds_move_page_guidance(self) -> None:
         payload = _build_error_payload(
             ConfigError("move-page requires different current and new parent IDs.")

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/tests/test_client.py

@@ -4,6 +4,21 @@ from unittest import mock
 from conjira_cli.client import ConfluenceClient, JiraClient
 
 
+class _FakeHTTPResponse:
+    def __init__(self, body: str, *, content_type: str) -> None:
+        self._body = body.encode("utf-8")
+        self.headers = {"Content-Type": content_type}
+
+    def read(self) -> bytes:
+        return self._body
+
+    def __enter__(self) -> "_FakeHTTPResponse":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        return False
+
+
 class ClientTests(unittest.TestCase):
     def test_update_page_from_snapshot_uses_snapshot_version_and_id(self) -> None:
         client = ConfluenceClient(base_url="https://confluence.example.com", token="token")
@@ -192,3 +207,69 @@ class ClientTests(unittest.TestCase):
 
         self.assertEqual([page["id"] for page in pages], ["1", "2", "3"])
         self.assertEqual(mock_get_child_pages.call_count, 2)
+
+class ValidateStorageHtmlTests(unittest.TestCase):
+    def test_valid_xhtml_passes(self) -> None:
+        from conjira_cli.client import validate_storage_html
+
+        # Should not raise
+        validate_storage_html("<p>Hello <strong>world</strong></p>")
+
+    def test_invalid_xhtml_raises(self) -> None:
+        from conjira_cli.client import validate_storage_html, ConfluenceError
+
+        with self.assertRaises(ConfluenceError) as ctx:
+            validate_storage_html("<p>Unclosed paragraph")
+        self.assertIn("well-formed XHTML", str(ctx.exception))
+
+    def test_bare_br_is_invalid(self) -> None:
+        from conjira_cli.client import validate_storage_html, ConfluenceError
+
+        with self.assertRaises(ConfluenceError):
+            validate_storage_html("<p>line<br>break</p>")
+
+    def test_valid_xhtml_with_confluence_macros_passes(self) -> None:
+        from conjira_cli.client import validate_storage_html
+
+        validate_storage_html(
+            '<ac:structured-macro ac:name="code" ac:schema-version="1">'
+            '<ac:parameter ac:name="language">python</ac:parameter>'
+            '<ac:plain-text-body><![CDATA[print("hi")]]></ac:plain-text-body>'
+            "</ac:structured-macro>"
+        )
+
+    def test_valid_xhtml_with_atlassian_namespace_passes(self) -> None:
+        from conjira_cli.client import validate_storage_html
+
+        validate_storage_html(
+            '<td atlassian:data-highlight-colour="blue">text</td>'
+        )
+
+    def test_get_page_parses_json_even_when_content_type_is_not_json(self) -> None:
+        client = ConfluenceClient(base_url="https://confluence.example.com", token="token")
+        body = (
+            '{"id":"123","type":"page","status":"current","title":"Demo",'
+            '"space":{"key":"TEST"},"version":{"number":7}}'
+        )
+
+        with mock.patch(
+            "conjira_cli.client.urllib.request.urlopen",
+            return_value=_FakeHTTPResponse(body, content_type="text/plain; charset=utf-8"),
+        ):
+            page = client.get_page("123")
+
+        self.assertEqual(page["id"], "123")
+        self.assertEqual(ConfluenceClient.summarize_page(page)["title"], "Demo")
+
+    def test_jira_auth_check_parses_json_even_when_content_type_is_not_json(self) -> None:
+        client = JiraClient(base_url="https://jira.example.com", token="token")
+        body = '{"version":"10.3.16","buildNumber":10030016,"deploymentType":"Server"}'
+
+        with mock.patch(
+            "conjira_cli.client.urllib.request.urlopen",
+            return_value=_FakeHTTPResponse(body, content_type="text/plain; charset=utf-8"),
+        ):
+            payload = client.auth_check()
+
+        self.assertEqual(payload["version"], "10.3.16")
+        self.assertEqual(payload["build_number"], 10030016)

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/tests/test_markdown_export.py

@@ -249,3 +249,49 @@ class MarkdownExportTests(unittest.TestCase):
         result = exporter.convert_fragment(html)
 
         self.assertIn("- Description emphasis", result)
+
+    def test_nested_table_pipes_escaped_in_cell(self) -> None:
+        """A nested table inside a cell must not break the outer table columns."""
+        exporter = MarkdownExporter(base_url="https://confluence.example.com", page_id="123")
+        # Outer 2-column table with headers that do NOT trigger structured
+        # detection so we get a regular pipe table.
+        html = (
+            "<table><tbody>"
+            "<tr><th>Host</th><th>Config</th></tr>"
+            "<tr>"
+            "<td>SSL cert</td>"
+            "<td><table><tbody>"
+            "<tr><td>Type</td><td>Wildcard</td></tr>"
+            "<tr><td>Issuer</td><td>DigiCert</td></tr>"
+            "</tbody></table></td>"
+            "</tr>"
+            "</tbody></table>"
+        )
+        result = exporter.convert_fragment(html)
+
+        # The outer table row for "SSL cert" should have nested table pipes
+        # escaped so it stays as a 2-column row.
+        for line in result.splitlines():
+            if "SSL cert" in line and line.strip().startswith("|"):
+                self.assertIn("\\|", line, "Nested table pipes should be escaped")
+                break
+        else:
+            self.fail("Could not find 'SSL cert' row in rendered table")
+
+    def test_nested_list_pipes_escaped_in_cell(self) -> None:
+        """A nested list with pipe chars inside a cell must escape them."""
+        exporter = MarkdownExporter(base_url="https://confluence.example.com", page_id="123")
+        html = (
+            "<table><tbody>"
+            "<tr><th>Task</th><th>Notes</th></tr>"
+            "<tr>"
+            "<td>Review</td>"
+            "<td><ul><li>Option A | Option B</li></ul></td>"
+            "</tr>"
+            "</tbody></table>"
+        )
+        result = exporter.convert_fragment(html)
+
+        for line in result.splitlines():
+            if "Review" in line and line.strip().startswith("|"):
+                self.assertIn("\\|", line, "Pipe in list item should be escaped")

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/tests/test_markdown_import.py

@@ -153,3 +153,148 @@ class MarkdownImportTests(unittest.TestCase):
         self.assertIn('<ac:structured-macro ac:name="status"', result)
         self.assertIn('<ac:parameter ac:name="colour">Blue</ac:parameter>', result)
         self.assertIn('<ac:parameter ac:name="title">Planned</ac:parameter>', result)
+
+    def test_xhtml_self_closing_br_tags(self) -> None:
+        """<br> must be emitted as <br /> for Confluence XHTML strict mode."""
+        # The current renderer doesn't emit bare <br> from markdown, but
+        # if inline HTML sneaks through we need the post-processor to fix it.
+        from conjira_cli.markdown_import import _ensure_xhtml_self_closing
+
+        self.assertEqual(_ensure_xhtml_self_closing("<br>"), "<br />")
+        self.assertEqual(_ensure_xhtml_self_closing("<br/>"), "<br />")
+        self.assertEqual(_ensure_xhtml_self_closing("<br />"), "<br />")
+        self.assertEqual(_ensure_xhtml_self_closing("<hr>"), "<hr />")
+        self.assertEqual(
+            _ensure_xhtml_self_closing("<p>text<br>more</p>"),
+            "<p>text<br />more</p>",
+        )
+
+    def test_xhtml_self_closing_preserves_attributes(self) -> None:
+        from conjira_cli.markdown_import import _ensure_xhtml_self_closing
+
+        self.assertEqual(
+            _ensure_xhtml_self_closing('<hr class="divider">'),
+            '<hr class="divider" />',
+        )
+
+    def test_xhtml_self_closing_img_tag(self) -> None:
+        from conjira_cli.markdown_import import _ensure_xhtml_self_closing
+
+        self.assertEqual(
+            _ensure_xhtml_self_closing('<img src="x.png">'),
+            '<img src="x.png" />',
+        )
+
+    def test_output_is_valid_xhtml(self) -> None:
+        """Full markdown-to-HTML output must be well-formed XHTML."""
+        import xml.etree.ElementTree as ET
+
+        result = markdown_to_storage_html(
+            "# Hello\n\nParagraph with **bold**.\n\n---\n"
+        )
+        wrapped = f'<root xmlns:ac="urn:ac" xmlns:ri="urn:ri">{result}</root>'
+        # Should not raise
+        ET.fromstring(wrapped)
+
+    def test_table_cell_passes_through_raw_html_list(self) -> None:
+        """Cells containing well-formed HTML blocks (e.g. nested <ul>) survive."""
+        result = markdown_to_storage_html(
+            "\n".join(
+                [
+                    "| 구분 | 내용 |",
+                    "| --- | --- |",
+                    "| 포인트 지급 | <ul><li>휴대폰 포인트 지급<ul><li>MDN 기준</li></ul></li></ul> |",
+                ]
+            )
+        )
+
+        self.assertIn(
+            "<td><ul><li>휴대폰 포인트 지급<ul><li>MDN 기준</li></ul></li></ul></td>",
+            result,
+        )
+        self.assertNotIn("&lt;ul&gt;", result)
+
+    def test_table_cell_passes_through_storage_macro(self) -> None:
+        """Cells containing ac:* / ri:* storage-format macros pass through."""
+        cell_html = (
+            '<ac:structured-macro ac:name="status" ac:schema-version="1">'
+            '<ac:parameter ac:name="colour">Green</ac:parameter>'
+            '<ac:parameter ac:name="title">Done</ac:parameter>'
+            "</ac:structured-macro>"
+        )
+        result = markdown_to_storage_html(
+            "\n".join(
+                [
+                    "| Item | Status |",
+                    "| --- | --- |",
+                    "| API | {0} |".format(cell_html),
+                ]
+            )
+        )
+
+        self.assertIn(cell_html, result)
+        self.assertNotIn("&lt;ac:", result)
+
+    def test_table_cell_with_inline_text_still_escapes(self) -> None:
+        """Cells without HTML block content still get inline escaping."""
+        result = markdown_to_storage_html(
+            "\n".join(
+                [
+                    "| Title | Note |",
+                    "| --- | --- |",
+                    "| 5 < 10 | not html |",
+                ]
+            )
+        )
+
+        self.assertIn("<td>5 &lt; 10</td>", result)
+        self.assertIn("<td>not html</td>", result)
+
+    def test_table_cell_with_malformed_html_falls_back_to_inline(self) -> None:
+        """If a cell looks like HTML but isn't well-formed, escape it instead of breaking the page."""
+        result = markdown_to_storage_html(
+            "\n".join(
+                [
+                    "| Item | Note |",
+                    "| --- | --- |",
+                    "| <ul><li>unclosed | broken |",
+                ]
+            )
+        )
+
+        # Malformed HTML must not pass through; it should be escaped.
+        self.assertNotIn("<td><ul><li>unclosed", result)
+        self.assertIn("&lt;ul&gt;", result)
+
+    def test_table_with_html_cells_is_valid_xhtml(self) -> None:
+        """Tables with HTML pass-through cells must produce valid XHTML."""
+        import xml.etree.ElementTree as ET
+
+        result = markdown_to_storage_html(
+            "\n".join(
+                [
+                    "| 구분 | 내용 |",
+                    "| --- | --- |",
+                    "| A | <ul><li>x<ul><li>y</li></ul></li></ul> |",
+                    "| B | plain text |",
+                ]
+            )
+        )
+        wrapped = f'<root xmlns:ac="urn:ac" xmlns:ri="urn:ri">{result}</root>'
+        ET.fromstring(wrapped)
+
+    def test_table_cell_html_block_emits_trailing_content_verbatim(self) -> None:
+        """Trailing content after an HTML block in a cell is emitted verbatim, not re-rendered."""
+        result = markdown_to_storage_html(
+            "\n".join(
+                [
+                    "| A | B |",
+                    "| --- | --- |",
+                    "| 1 | <ul><li>x</li></ul> trailing [link](http://example.com) |",
+                ]
+            )
+        )
+
+        # 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)

{conjira_cli-0.2.3 → conjira_cli-0.2.5}/tests/test_section_edit.py

@@ -1,6 +1,10 @@
 import unittest
 
-from conjira_cli.section_edit import SectionEditError, replace_section_html
+from conjira_cli.section_edit import (
+    SectionEditError,
+    insert_after_heading_html,
+    replace_section_html,
+)
 
 
 class SectionEditTests(unittest.TestCase):
@@ -46,3 +50,44 @@ class SectionEditTests(unittest.TestCase):
                 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>",
+            )