confpub-cli 1.7.3__tar.gz → 1.7.5__tar.gz

{confpub_cli-1.7.3 → confpub_cli-1.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confpub-cli
-Version: 1.7.3
+Version: 1.7.5
 Summary: Agent-first CLI to publish Markdown to Confluence
 Project-URL: Homepage, https://github.com/ThomasRohde/confpub-cli
 Project-URL: Repository, https://github.com/ThomasRohde/confpub-cli.git

{confpub_cli-1.7.3 → confpub_cli-1.7.5}/confpub/__init__.py

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

{confpub_cli-1.7.3 → confpub_cli-1.7.5}/confpub/front_matter.py

@@ -10,6 +10,8 @@ import dataclasses
 from dataclasses import dataclass, field
 from typing import Any
 
+import yaml
+
 from confpub.converter import extract_front_matter
 from confpub.errors import ERR_VALIDATION_MARKDOWN, ConfpubError
 
@@ -24,6 +26,22 @@ class FrontMatterData:
     labels: list[str] = field(default_factory=list)
     page_id: str | None = None
 
+    def to_yaml_block(self) -> str:
+        """Serialize to a YAML front matter block (``--- ... ---``)."""
+        data: dict[str, Any] = {}
+        if self.title is not None:
+            data["title"] = self.title
+        if self.page_id is not None:
+            data["page_id"] = self.page_id
+        if self.space is not None:
+            data["space"] = self.space
+        if self.parent is not None:
+            data["parent"] = self.parent
+        if self.labels:
+            data["labels"] = self.labels
+        yaml_str = yaml.dump(data, default_flow_style=False, allow_unicode=True, sort_keys=False)
+        return f"---\n{yaml_str}---\n\n"
+
 
 def _validate_string(raw: dict[str, Any], key: str) -> str | None:
     """Extract and validate a string field, or None if absent."""

{confpub_cli-1.7.3 → confpub_cli-1.7.5}/confpub/manifest.py

@@ -191,6 +191,9 @@ def generate_manifest_yaml(
         result = []
         for p in pages:
             entry: dict[str, Any] = {"title": p["title"], "file": p["file"]}
+            assets = p.get("assets", [])
+            if assets:
+                entry["assets"] = assets
             labels = p.get("labels", [])
             if labels:
                 entry["labels"] = labels

{confpub_cli-1.7.3 → confpub_cli-1.7.5}/confpub/puller.py

@@ -9,9 +9,7 @@ from __future__ import annotations
 import os
 import re
 from pathlib import Path
-from typing import Any
-
-import yaml
+from typing import Any, Literal
 
 from confpub.confluence import ConfluenceClient, build_client
 from confpub.output import emit_progress
@@ -21,10 +19,13 @@ from confpub.errors import (
     ERR_VALIDATION_REQUIRED,
     ConfpubError,
 )
+from confpub.front_matter import FrontMatterData
 from confpub.lockfile import Lockfile, load_lockfile, save_lockfile, update_lockfile
 from confpub.manifest import generate_manifest_yaml
 from confpub.reverse_converter import convert_storage_to_markdown
 
+Layout = Literal["flat", "nested"]
+
 
 def _slugify(title: str) -> str:
     """Convert a page title to a filename-safe slug.
@@ -77,15 +78,22 @@ def _collect_tree(
 def _compute_file_paths(
     pages: list[dict[str, Any]],
     output_dir: str,
-    layout: str,
+    layout: Layout,
     root_page_id: str,
-) -> dict[str, str]:
-    """Compute output file paths for each page. Returns {page_id: file_path}."""
+) -> tuple[dict[str, str], dict[str, str], dict[str, str | None]]:
+    """Compute output file paths and lookup maps for each page.
+
+    Returns (file_paths, id_to_title, id_to_parent) where:
+    - file_paths: {page_id: file_path}
+    - id_to_title: {page_id: title}
+    - id_to_parent: {page_id: parent_page_id or None}
+    """
     paths: dict[str, str] = {}
     root_slug: str | None = None
 
-    # Build parent lookup
+    # Build lookup maps
     id_to_slug: dict[str, str] = {}
+    id_to_title: dict[str, str] = {}
     id_to_parent: dict[str, str | None] = {}
 
     for entry in pages:
@@ -93,6 +101,7 @@ def _compute_file_paths(
         pid = str(page["id"])
         slug = _slugify(page.get("title", pid))
         id_to_slug[pid] = slug
+        id_to_title[pid] = page.get("title", "")
         id_to_parent[pid] = str(entry["parent_id"]) if entry["parent_id"] else None
         if pid == root_page_id:
             root_slug = slug
@@ -119,7 +128,7 @@ def _compute_file_paths(
             # Flat layout
             paths[pid] = os.path.join(output_dir, f"{slug}.md")
 
-    return paths
+    return paths, id_to_title, id_to_parent
 
 
 def _check_conflicts(file_paths: dict[str, str], force: bool) -> None:
@@ -147,7 +156,7 @@ def _download_page_attachments(
     page_id: str,
     slug: str,
     output_dir: str,
-    layout: str,
+    layout: Layout,
     warnings: list[str],
     file_path: str | None = None,
 ) -> dict[str, str]:
@@ -164,8 +173,6 @@ def _download_page_attachments(
     if layout == "nested" and file_path:
         # Place assets next to the markdown file (e.g. .../page-slug/assets/)
         assets_dir = os.path.join(os.path.dirname(file_path), "assets")
-    elif layout == "nested":
-        assets_dir = os.path.join(output_dir, slug, "assets")
     else:
         assets_dir = os.path.join(output_dir, "assets", slug)
 
@@ -194,11 +201,13 @@ def _build_page_tree(
     root_page_id: str,
     output_dir: str = ".",
     page_labels: dict[str, list[str]] | None = None,
+    page_assets: dict[str, list[str]] | None = None,
 ) -> list[dict[str, Any]]:
     """Build a hierarchical page tree for manifest generation."""
     id_to_entry: dict[str, dict[str, Any]] = {}
     children_map: dict[str | None, list[str]] = {}
     labels_map = page_labels or {}
+    assets_map = page_assets or {}
 
     for entry in pages:
         page = entry["page"]
@@ -214,6 +223,8 @@ def _build_page_tree(
         }
         if labels_map.get(pid):
             node["labels"] = labels_map[pid]
+        if assets_map.get(pid):
+            node["assets"] = assets_map[pid]
         id_to_entry[pid] = node
         children_map.setdefault(parent_id, []).append(pid)
 
@@ -230,27 +241,6 @@ def _build_page_tree(
     return [root_entry]
 
 
-def _build_front_matter(
-    title: str,
-    page_id: str,
-    space: str,
-    parent: str | None = None,
-    labels: list[str] | None = None,
-) -> str:
-    """Build a YAML front matter block for a pulled markdown file."""
-    data: dict[str, Any] = {
-        "title": title,
-        "page_id": page_id,
-        "space": space,
-    }
-    if parent:
-        data["parent"] = parent
-    if labels:
-        data["labels"] = labels
-    yaml_str = yaml.dump(data, default_flow_style=False, allow_unicode=True, sort_keys=False)
-    return f"---\n{yaml_str}---\n\n"
-
-
 def pull_pages(
     *,
     space: str | None = None,
@@ -259,7 +249,7 @@ def pull_pages(
     output_dir: str = ".",
     recursive: bool = False,
     force: bool = False,
-    layout: str = "flat",
+    layout: Layout = "flat",
     include_attachments: bool = True,
 ) -> dict[str, Any]:
     """Pull pages from Confluence to local Markdown files.
@@ -292,29 +282,21 @@ def pull_pages(
     # Collect all pages to pull
     all_pages = _collect_tree(client, root_id, recursive)
 
-    # Compute output file paths
-    file_paths = _compute_file_paths(all_pages, output_dir, layout, root_id)
+    # Compute output file paths and lookup maps
+    file_paths, id_to_title, id_to_parent = _compute_file_paths(all_pages, output_dir, layout, root_id)
 
     # Check for conflicts
     _check_conflicts(file_paths, force)
 
-    # Build lookup maps for front matter parent resolution
-    id_to_title: dict[str, str] = {}
-    id_to_parent: dict[str, str | None] = {}
-    for entry in all_pages:
-        page = entry["page"]
-        pid = str(page["id"])
-        id_to_title[pid] = page.get("title", "")
-        id_to_parent[pid] = str(entry["parent_id"]) if entry["parent_id"] else None
-
-    # Get the root page's parent in Confluence (for front matter + manifest)
-    ancestors = client.get_page_ancestors(root_id)
+    # Get the root page's parent from already-fetched ancestors (no extra API call)
+    ancestors = root_page.get("ancestors", [])
     root_parent_title = ancestors[-1].get("title", "") if ancestors else None
 
     # Process each page
     files_result: list[dict[str, Any]] = []
     total_attachments = 0
     pull_warnings: list[str] = []
+    pulled_assets: dict[str, list[str]] = {}  # page_id -> list of relative asset paths
 
     for entry in all_pages:
         page = entry["page"]
@@ -335,6 +317,8 @@ def pull_pages(
             )
             attachments_downloaded = len(attachment_map)
             total_attachments += attachments_downloaded
+            if attachment_map:
+                pulled_assets[pid] = list(attachment_map.values())
 
         # Convert storage format to markdown
         body_storage = page.get("body", {}).get("storage", {}).get("value", "")
@@ -353,14 +337,14 @@ def pull_pages(
             parent_title = id_to_title.get(par_id) if par_id else None
 
         # Build and prepend front matter
-        front_matter = _build_front_matter(
+        fm = FrontMatterData(
             title=page_title,
             page_id=pid,
             space=root_space,
             parent=parent_title,
-            labels=page_labels,
+            labels=page_labels or [],
         )
-        markdown_content = front_matter + conv_result.markdown
+        markdown_content = fm.to_yaml_block() + conv_result.markdown
 
         # Write markdown file
         os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
@@ -377,11 +361,11 @@ def pull_pages(
 
     # Always generate manifest
     root_title = root_page.get("title", "")
-    manifest_parent = ancestors[-1].get("title", root_title) if ancestors else root_title
+    manifest_parent = root_parent_title or root_title
     pulled_labels: dict[str, list[str]] = {
         f["page_id"]: f.get("labels", []) for f in files_result
     }
-    page_tree = _build_page_tree(all_pages, file_paths, root_id, output_dir, page_labels=pulled_labels)
+    page_tree = _build_page_tree(all_pages, file_paths, root_id, output_dir, page_labels=pulled_labels, page_assets=pulled_assets)
     manifest_yaml = generate_manifest_yaml(root_space, manifest_parent, page_tree)
     manifest_path = os.path.join(output_dir, "confpub.yaml")
     Path(manifest_path).write_text(manifest_yaml, encoding="utf-8")

{confpub_cli-1.7.3 → confpub_cli-1.7.5}/tests/test_puller.py

@@ -10,7 +10,8 @@ import pytest
 import yaml
 
 from confpub.errors import ERR_CONFLICT_FILE_EXISTS, ERR_VALIDATION_REQUIRED, ConfpubError
-from confpub.puller import _build_front_matter, _slugify, pull_pages
+from confpub.front_matter import FrontMatterData
+from confpub.puller import _slugify, pull_pages
 
 
 # ---------------------------------------------------------------------------
@@ -594,10 +595,10 @@ class TestManifestFlag:
 
 class TestBuildFrontMatter:
     def test_basic_fields(self):
-        fm = _build_front_matter("My Page", "123", "SD")
-        assert fm.startswith("---\n")
-        assert fm.endswith("---\n\n")
-        parsed = yaml.safe_load(fm.strip("- \n"))
+        block = FrontMatterData(title="My Page", page_id="123", space="SD").to_yaml_block()
+        assert block.startswith("---\n")
+        assert block.endswith("---\n\n")
+        parsed = yaml.safe_load(block.strip("- \n"))
         assert parsed["title"] == "My Page"
         assert parsed["page_id"] == "123"
         assert parsed["space"] == "SD"
@@ -605,14 +606,17 @@ class TestBuildFrontMatter:
         assert "labels" not in parsed
 
     def test_with_parent_and_labels(self):
-        fm = _build_front_matter("Child", "456", "SD", parent="Parent Page", labels=["a", "b"])
-        parsed = yaml.safe_load(fm.strip("- \n"))
+        block = FrontMatterData(
+            title="Child", page_id="456", space="SD",
+            parent="Parent Page", labels=["a", "b"],
+        ).to_yaml_block()
+        parsed = yaml.safe_load(block.strip("- \n"))
         assert parsed["parent"] == "Parent Page"
         assert parsed["labels"] == ["a", "b"]
 
     def test_empty_labels_omitted(self):
-        fm = _build_front_matter("Page", "1", "SD", labels=[])
-        parsed = yaml.safe_load(fm.strip("- \n"))
+        block = FrontMatterData(title="Page", page_id="1", space="SD").to_yaml_block()
+        parsed = yaml.safe_load(block.strip("- \n"))
         assert "labels" not in parsed
 
 
@@ -661,8 +665,8 @@ class TestFrontMatterInPulledFiles:
     def test_root_page_has_parent_from_ancestors(self, tmp_path):
         """Root page gets parent from Confluence ancestors."""
         page = _make_page("1", "Root")
+        page["ancestors"] = [{"title": "Space Home"}]
         client = _mock_client({"1": page})
-        client.get_page_ancestors = lambda pid: [{"title": "Space Home"}]
 
         with patch("confpub.puller.build_client", return_value=client):
             pull_pages(page_id="1", output_dir=str(tmp_path))