confpub-cli 1.7.2__tar.gz → 1.7.4__tar.gz

{confpub_cli-1.7.2 → confpub_cli-1.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confpub-cli
-Version: 1.7.2
+Version: 1.7.4
 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.2 → confpub_cli-1.7.4}/confpub/__init__.py

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

{confpub_cli-1.7.2 → confpub_cli-1.7.4}/confpub/cli.py

@@ -357,7 +357,6 @@ def page_pull(
     force: bool = typer.Option(False, "--force", help="Overwrite existing files"),
     layout: str = typer.Option("flat", "--layout", help="Output layout: flat or nested"),
     no_attachments: bool = typer.Option(False, "--no-attachments", help="Skip downloading attachments"),
-    manifest: bool = typer.Option(False, "--manifest", help="Generate confpub.yaml manifest"),
 ) -> None:
     """Pull Confluence pages to local Markdown files."""
     with command_context("page.pull", target={"space": space, "title": title, "page_id": page_id}) as ctx:
@@ -378,7 +377,6 @@ def page_pull(
             force=force,
             layout=layout,
             include_attachments=not no_attachments,
-            generate_manifest=manifest,
         )
         ctx.warnings.extend(result.pop("warnings", []))
         ctx.result = result

{confpub_cli-1.7.2 → confpub_cli-1.7.4}/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.2 → confpub_cli-1.7.4}/confpub/puller.py

@@ -11,6 +11,8 @@ import re
 from pathlib import Path
 from typing import Any
 
+import yaml
+
 from confpub.confluence import ConfluenceClient, build_client
 from confpub.output import emit_progress
 from confpub.errors import (
@@ -147,6 +149,7 @@ def _download_page_attachments(
     output_dir: str,
     layout: str,
     warnings: list[str],
+    file_path: str | None = None,
 ) -> dict[str, str]:
     """Download attachments for a page. Returns {attachment_name: local_path}.
 
@@ -158,7 +161,10 @@ def _download_page_attachments(
     if not attachments:
         return attachment_map
 
-    if layout == "nested":
+    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)
@@ -188,11 +194,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"]
@@ -208,6 +216,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)
 
@@ -224,6 +234,27 @@ 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,
@@ -234,7 +265,6 @@ def pull_pages(
     force: bool = False,
     layout: str = "flat",
     include_attachments: bool = True,
-    generate_manifest: bool = False,
 ) -> dict[str, Any]:
     """Pull pages from Confluence to local Markdown files.
 
@@ -272,10 +302,24 @@ def pull_pages(
     # 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)
+    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"]
@@ -288,27 +332,47 @@ def pull_pages(
         # Download attachments
         attachment_map: dict[str, str] = {}
         attachments_downloaded = 0
+        out_path = file_paths[pid]
         if include_attachments:
             attachment_map = _download_page_attachments(
                 client, pid, slug, output_dir, layout, pull_warnings,
+                file_path=out_path,
             )
             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", "")
-        result = convert_storage_to_markdown(
+        conv_result = convert_storage_to_markdown(
             body_storage, attachment_map=attachment_map,
         )
 
-        # Write markdown file
-        out_path = file_paths[pid]
-        os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
-        Path(out_path).write_text(result.markdown, encoding="utf-8")
-
         # Fetch labels
         page_labels = [lbl["name"] for lbl in client.get_labels(pid)]
 
+        # Determine parent title for front matter
+        if pid == root_id:
+            parent_title = root_parent_title
+        else:
+            par_id = id_to_parent.get(pid)
+            parent_title = id_to_title.get(par_id) if par_id else None
+
+        # Build and prepend front matter
+        front_matter = _build_front_matter(
+            title=page_title,
+            page_id=pid,
+            space=root_space,
+            parent=parent_title,
+            labels=page_labels,
+        )
+        markdown_content = front_matter + conv_result.markdown
+
+        # Write markdown file
+        os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
+        Path(out_path).write_text(markdown_content, encoding="utf-8")
+
         files_result.append({
             "page_id": pid,
             "title": page_title,
@@ -318,22 +382,17 @@ def pull_pages(
             "labels": page_labels,
         })
 
-    # Generate manifest if explicitly requested
-    manifest_file: str | None = None
-    if generate_manifest:
-        root_title = root_page.get("title", "")
-        # Determine the actual parent of the root page
-        ancestors = client.get_page_ancestors(root_id)
-        manifest_parent = ancestors[-1].get("title", root_title) if ancestors else root_title
-        # Collect labels by page ID for manifest generation
-        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)
-        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")
-        manifest_file = manifest_path
+    # Always generate manifest
+    root_title = root_page.get("title", "")
+    manifest_parent = ancestors[-1].get("title", root_title) if ancestors else 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_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")
+    manifest_file: str = manifest_path
 
     # Update lockfile
     lockfile_path = os.path.join(output_dir, "confpub.lock")
@@ -356,6 +415,6 @@ def pull_pages(
         "summary": {
             "pages_pulled": len(files_result),
             "attachments_downloaded": total_attachments,
-            "manifest_generated": manifest_file is not None,
+            "manifest_generated": True,
         },
     }

{confpub_cli-1.7.2 → confpub_cli-1.7.4}/tests/test_puller.py

@@ -7,8 +7,10 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
+import yaml
+
 from confpub.errors import ERR_CONFLICT_FILE_EXISTS, ERR_VALIDATION_REQUIRED, ConfpubError
-from confpub.puller import _slugify, pull_pages
+from confpub.puller import _build_front_matter, _slugify, pull_pages
 
 
 # ---------------------------------------------------------------------------
@@ -61,12 +63,16 @@ def _mock_client(pages: dict[str, dict], children: dict[str, list] | None = None
     def get_page_ancestors(pid):
         return []
 
+    def get_labels(pid):
+        return []
+
     client.get_page_by_id = get_page_by_id
     client.get_page = get_page
     client.get_page_children_deep = get_page_children_deep
     client.get_attachments = get_attachments
     client.download_attachment = download_attachment
     client.get_page_ancestors = get_page_ancestors
+    client.get_labels = get_labels
     return client
 
 
@@ -113,11 +119,14 @@ class TestSinglePagePull:
         assert result["files"][0]["page_id"] == "123"
         assert result["files"][0]["title"] == "Overview"
 
-        # File should exist
+        # File should exist with front matter
         md_file = tmp_path / "overview.md"
         assert md_file.exists()
         content = md_file.read_text()
+        assert content.startswith("---\n")
         assert "Hello world" in content
+        assert "page_id: '123'" in content
+        assert "title: Overview" in content
 
     def test_pull_single_page_by_space_title(self, tmp_path):
         page = _make_page("456", "Getting Started", "<h1>Welcome</h1>")
@@ -180,7 +189,6 @@ class TestRecursivePull:
                 page_id="1",
                 output_dir=str(tmp_path),
                 recursive=True,
-                generate_manifest=True,
             )
 
         assert result["summary"]["manifest_generated"] is True
@@ -410,7 +418,6 @@ class TestDataCenterCompat:
             result = pull_pages(
                 space="PROJ", title="Root",
                 output_dir=str(tmp_path), recursive=True,
-                generate_manifest=True,
             )
 
         assert result["summary"]["pages_pulled"] == 2
@@ -482,6 +489,7 @@ class TestMultiLevelRecursivePull:
         assert (tmp_path / "child.md").exists()
         assert (tmp_path / "grandchild.md").exists()
         gc_content = (tmp_path / "grandchild.md").read_text()
+        assert gc_content.startswith("---\n")
         assert "Deep content" in gc_content
 
     def test_page_id_recursive_combination(self, tmp_path):
@@ -527,7 +535,6 @@ class TestManifestPathSeparators:
                 output_dir=str(tmp_path),
                 recursive=True,
                 layout="nested",
-                generate_manifest=True,
             )
 
         manifest_content = Path(result["manifest_file"]).read_text()
@@ -537,10 +544,10 @@ class TestManifestPathSeparators:
                 assert "\\" not in line, f"Backslash found in manifest path: {line}"
 
 
-class TestNestedLayoutNoAutoManifest:
-    """Bug 4: --layout nested without --manifest should NOT create confpub.yaml."""
+class TestManifestAlwaysGenerated:
+    """Manifest is always generated regardless of layout."""
 
-    def test_nested_without_manifest_flag(self, tmp_path):
+    def test_nested_always_generates_manifest(self, tmp_path):
         root = _make_page("1", "Root")
         child = _make_page("2", "Child")
         pages = {"1": root, "2": child}
@@ -553,17 +560,16 @@ class TestNestedLayoutNoAutoManifest:
                 output_dir=str(tmp_path),
                 recursive=True,
                 layout="nested",
-                generate_manifest=False,
             )
 
-        assert result["summary"]["manifest_generated"] is False
-        assert result["manifest_file"] is None
-        assert not (tmp_path / "confpub.yaml").exists()
+        assert result["summary"]["manifest_generated"] is True
+        assert result["manifest_file"] is not None
+        assert (tmp_path / "confpub.yaml").exists()
 
 
 class TestManifestFlag:
-    def test_single_page_with_manifest_flag(self, tmp_path):
-        """--manifest generates confpub.yaml even for a single page."""
+    def test_single_page_generates_manifest(self, tmp_path):
+        """Manifest is always generated, even for a single page."""
         page = _make_page("1", "Solo Page")
         client = _mock_client({"1": page})
 
@@ -571,7 +577,6 @@ class TestManifestFlag:
             result = pull_pages(
                 page_id="1",
                 output_dir=str(tmp_path),
-                generate_manifest=True,
             )
 
         assert result["summary"]["manifest_generated"] is True
@@ -580,3 +585,89 @@ class TestManifestFlag:
         assert manifest.exists()
         content = manifest.read_text()
         assert "Solo Page" in content
+
+
+# ---------------------------------------------------------------------------
+# Front matter tests
+# ---------------------------------------------------------------------------
+
+
+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"))
+        assert parsed["title"] == "My Page"
+        assert parsed["page_id"] == "123"
+        assert parsed["space"] == "SD"
+        assert "parent" not in parsed
+        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"))
+        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"))
+        assert "labels" not in parsed
+
+
+class TestFrontMatterInPulledFiles:
+    def test_front_matter_fields_correct(self, tmp_path):
+        """Pulled files contain correct front matter metadata."""
+        root = _make_page("1", "Root", space_key="SD")
+        child = _make_page("2", "Child Page", "<p>Body</p>", space_key="SD")
+        pages = {"1": root, "2": child}
+        children = {"1": [child]}
+        client = _mock_client(pages, children)
+        client.get_labels = lambda pid: [{"name": "my-label"}] if pid == "2" else []
+
+        with patch("confpub.puller.build_client", return_value=client):
+            pull_pages(
+                page_id="1",
+                output_dir=str(tmp_path),
+                recursive=True,
+            )
+
+        # Check child file front matter
+        child_content = (tmp_path / "child-page.md").read_text()
+        assert child_content.startswith("---\n")
+        # Extract YAML block
+        parts = child_content.split("---\n", 2)
+        fm = yaml.safe_load(parts[1])
+        assert fm["title"] == "Child Page"
+        assert fm["page_id"] == "2"
+        assert fm["space"] == "SD"
+        assert fm["parent"] == "Root"
+        assert fm["labels"] == ["my-label"]
+
+    def test_root_page_has_no_parent_when_no_ancestors(self, tmp_path):
+        """Root page omits parent when Confluence has no ancestors."""
+        page = _make_page("1", "Root")
+        client = _mock_client({"1": page})
+
+        with patch("confpub.puller.build_client", return_value=client):
+            pull_pages(page_id="1", output_dir=str(tmp_path))
+
+        content = (tmp_path / "root.md").read_text()
+        parts = content.split("---\n", 2)
+        fm = yaml.safe_load(parts[1])
+        assert "parent" not in fm
+
+    def test_root_page_has_parent_from_ancestors(self, tmp_path):
+        """Root page gets parent from Confluence ancestors."""
+        page = _make_page("1", "Root")
+        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))
+
+        content = (tmp_path / "root.md").read_text()
+        parts = content.split("---\n", 2)
+        fm = yaml.safe_load(parts[1])
+        assert fm["parent"] == "Space Home"