confpub-cli 1.1.0__tar.gz → 1.3.0__tar.gz

{confpub_cli-1.1.0 → confpub_cli-1.3.0}/PKG-INFO

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

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

{confpub_cli-1.1.0 → confpub_cli-1.3.0}/confpub/applier.py

@@ -13,7 +13,7 @@ from typing import Any
 
 from confpub.assets import AssetRef, discover_assets, rewrite_image_urls, upload_assets
 from confpub.config import load_config
-from confpub.confluence import ConfluenceClient
+from confpub.confluence import ConfluenceClient, build_page_url
 from confpub.converter import convert_markdown, fingerprint_content
 from confpub.errors import ERR_CONFLICT_FINGERPRINT, ERR_IO_FILE_NOT_FOUND, ConfpubError
 from confpub.lockfile import Lockfile, load_lockfile, save_lockfile, update_lockfile
@@ -43,7 +43,7 @@ def apply_plan(
     lockfile = load_lockfile(lockfile_path) or Lockfile()
 
     changes: list[dict[str, Any]] = []
-    counts = {"create": 0, "update": 0, "attachments_upload": 0}
+    counts = {"create": 0, "update": 0, "attachments_upload": 0, "labels_applied": 0}
 
     # Resolve parent page IDs by title
     parent_ids: dict[str, str] = {}  # title → page_id
@@ -113,6 +113,10 @@ def apply_plan(
                     new_version = new_version.get("number", 1)
                 change["after"]["page_id"] = new_id
                 change["after"]["version"] = new_version
+                change["after"]["webui"] = build_page_url(
+                    config.base_url or "", config.is_cloud,
+                    plan.space, new_id, page.title,
+                )
 
                 # Upload attachments
                 if assets:
@@ -124,9 +128,19 @@ def apply_plan(
                     change["attachments_added"] = [a.source_path for a in assets]
                     counts["attachments_upload"] += len(assets)
 
+                # Apply labels
+                if page.labels:
+                    client.set_labels(new_id, page.labels)
+                    change["labels_added"] = page.labels
+                    counts["labels_applied"] += len(page.labels)
+
                 # Update lockfile and parent tracking
                 update_lockfile(lockfile, page.title, new_id, new_version if isinstance(new_version, int) else 1, content_fingerprint=fingerprint_content(storage))
                 parent_ids[page.title] = new_id
+            else:
+                # Dry-run: report labels
+                if page.labels:
+                    change["labels_to_apply"] = page.labels
 
             counts["create"] += 1
             changes.append(change)
@@ -167,6 +181,10 @@ def apply_plan(
                 if isinstance(new_version, dict):
                     new_version = new_version.get("number", (before_version or 0) + 1)
                 change["after"]["version"] = new_version
+                change["after"]["webui"] = build_page_url(
+                    config.base_url or "", config.is_cloud,
+                    plan.space, page.confluence_page_id, page.title,
+                )
 
                 # Upload attachments
                 if assets:
@@ -176,12 +194,22 @@ def apply_plan(
                     change["attachments_added"] = [a.source_path for a in assets]
                     counts["attachments_upload"] += len(assets)
 
+                # Apply labels
+                if page.labels:
+                    client.set_labels(page.confluence_page_id, page.labels)
+                    change["labels_added"] = page.labels
+                    counts["labels_applied"] += len(page.labels)
+
                 update_lockfile(
                     lockfile, page.title, page.confluence_page_id,
                     new_version if isinstance(new_version, int) else 1,
                     content_fingerprint=fingerprint_content(storage),
                 )
                 parent_ids[page.title] = page.confluence_page_id
+            else:
+                # Dry-run: report labels
+                if page.labels:
+                    change["labels_to_apply"] = page.labels
 
             counts["update"] += 1
             changes.append(change)

{confpub_cli-1.1.0 → confpub_cli-1.3.0}/confpub/cli.py

@@ -38,6 +38,8 @@ auth_app = typer.Typer(help="Authentication", callback=_group_callback)
 config_app = typer.Typer(help="Configuration", callback=_group_callback)
 space_app = typer.Typer(help="Space operations", callback=_group_callback)
 attachment_app = typer.Typer(help="Attachment operations", callback=_group_callback)
+label_app = typer.Typer(help="Label operations", callback=_group_callback)
+comment_app = typer.Typer(help="Comment operations", callback=_group_callback)
 
 # ---------------------------------------------------------------------------
 # Main app
@@ -55,6 +57,8 @@ app.add_typer(auth_app, name="auth")
 app.add_typer(config_app, name="config")
 app.add_typer(space_app, name="space")
 app.add_typer(attachment_app, name="attachment")
+app.add_typer(label_app, name="label")
+app.add_typer(comment_app, name="comment")
 
 
 def _version_callback(value: bool) -> None:
@@ -189,7 +193,7 @@ def page_list(
         from confpub.confluence import build_client, _slim_page
         client = build_client()
         pages = client.list_pages(space, start=start, limit=limit)
-        ctx.result = {"pages": [_slim_page(p, base_url=client._config.base_url.rstrip("/")) for p in pages]}
+        ctx.result = {"pages": [_slim_page(p, base_url=client._config.base_url.rstrip("/"), is_cloud=client._config.is_cloud) for p in pages]}
 
 
 @page_app.command("inspect")
@@ -217,7 +221,7 @@ def page_inspect(
         if raw:
             ctx.result = page
         else:
-            result = _slim_page(page, base_url=client._config.base_url.rstrip("/"))
+            result = _slim_page(page, base_url=client._config.base_url.rstrip("/"), is_cloud=client._config.is_cloud)
             if format == "markdown" and "body_storage" in result:
                 from confpub.reverse_converter import convert_storage_to_markdown
                 conversion = convert_storage_to_markdown(result["body_storage"])
@@ -239,6 +243,7 @@ def page_publish(
     page_id: Optional[str] = typer.Option(None, "--page-id", help="Confluence page ID (skip lookup, update directly)"),
     dry_run: bool = typer.Option(False, "--dry-run", help="Preview changes without writing"),
     backup: bool = typer.Option(False, "--backup", help="Backup existing page before overwriting"),
+    label: Optional[list[str]] = typer.Option(None, "--label", help="Label to apply (repeatable)"),
 ) -> None:
     """Publish a single Markdown file to Confluence."""
     from confpub.publish import derive_title
@@ -262,6 +267,7 @@ def page_publish(
             dry_run=dry_run,
             backup=backup,
             progress_callback=ctx,
+            labels=label or [],
         )
         ctx.result = result
 
@@ -351,6 +357,43 @@ def page_delete(
         ctx.result = result
 
 
+@page_app.command("move")
+def page_move(
+    page_id: str = typer.Option(..., "--page-id", help="Confluence page ID to move"),
+    target_parent: Optional[str] = typer.Option(None, "--target-parent", help="Title of the new parent page"),
+    space: Optional[str] = typer.Option(None, "--space", help="Space key (required with --target-parent)"),
+    target_parent_id: Optional[str] = typer.Option(None, "--target-parent-id", help="Page ID of the new parent"),
+) -> None:
+    """Move a page under a new parent."""
+    target = {"page_id": page_id}
+    with command_context("page.move", target=target) as ctx:
+        if not target_parent and not target_parent_id:
+            raise ConfpubError(
+                "ERR_VALIDATION_REQUIRED",
+                "Either --target-parent or --target-parent-id is required",
+            )
+        if target_parent and not space:
+            raise ConfpubError(
+                "ERR_VALIDATION_REQUIRED",
+                "--space is required when using --target-parent",
+            )
+        from confpub.confluence import build_client
+        client = build_client()
+
+        if target_parent_id:
+            # Use target_id directly — more reliable, no title resolution needed
+            parent_page = client.get_page_by_id(target_parent_id)
+            if not parent_page or not parent_page.get("id"):
+                from confpub.errors import ERR_VALIDATION_NOT_FOUND
+                raise ConfpubError(ERR_VALIDATION_NOT_FOUND, f"Target parent page not found: {target_parent_id}")
+            resolved_space = parent_page.get("space", {}).get("key", space or "")
+            result = client.move_page(resolved_space, page_id, target_id=target_parent_id)
+        else:
+            result = client.move_page(space, page_id, target_title=target_parent)
+
+        ctx.result = result
+
+
 @space_app.command("list")
 def space_list() -> None:
     """List accessible Confluence spaces."""
@@ -481,6 +524,111 @@ def config_inspect() -> None:
         ctx.result = config.to_display_dict()
 
 
+# ---------------------------------------------------------------------------
+# Label commands
+# ---------------------------------------------------------------------------
+
+
+@label_app.command("list")
+def label_list(
+    page_id: str = typer.Option(..., "--page-id", help="Confluence page ID"),
+) -> None:
+    """List labels on a Confluence page."""
+    with command_context("label.list", target={"page_id": page_id}) as ctx:
+        from confpub.confluence import build_client
+        client = build_client()
+        labels = client.get_labels(page_id)
+        ctx.result = {"labels": labels, "count": len(labels)}
+
+
+@label_app.command("add")
+def label_add(
+    page_id: str = typer.Option(..., "--page-id", help="Confluence page ID"),
+    label: list[str] = typer.Option(..., "--label", help="Label name (repeatable)"),
+) -> None:
+    """Add labels to a Confluence page."""
+    with command_context("label.add", target={"page_id": page_id}) as ctx:
+        from confpub.errors import ERR_VALIDATION_LABEL
+        # Validate labels
+        for lbl in label:
+            if " " in lbl:
+                raise ConfpubError(
+                    ERR_VALIDATION_LABEL,
+                    f"Label must not contain spaces: '{lbl}'",
+                    details={"label": lbl},
+                )
+            if len(lbl) > 255:
+                raise ConfpubError(
+                    ERR_VALIDATION_LABEL,
+                    f"Label exceeds 255 characters: '{lbl[:50]}...'",
+                    details={"label": lbl, "length": len(lbl)},
+                )
+
+        from confpub.confluence import build_client
+        client = build_client()
+        results = client.set_labels(page_id, label)
+        ctx.result = {"labels_added": label, "results": results}
+
+
+@label_app.command("remove")
+def label_remove(
+    page_id: str = typer.Option(..., "--page-id", help="Confluence page ID"),
+    label: list[str] = typer.Option(..., "--label", help="Label name to remove (repeatable)"),
+) -> None:
+    """Remove labels from a Confluence page."""
+    with command_context("label.remove", target={"page_id": page_id}) as ctx:
+        from confpub.confluence import build_client
+        client = build_client()
+        results = []
+        for lbl in label:
+            result = client.remove_label(page_id, lbl)
+            results.append(result)
+        ctx.result = {"labels_removed": label, "results": results}
+
+
+# ---------------------------------------------------------------------------
+# Comment commands
+# ---------------------------------------------------------------------------
+
+
+@comment_app.command("add")
+def comment_add(
+    page_id: str = typer.Option(..., "--page-id", help="Confluence page ID"),
+    text: Optional[str] = typer.Option(None, "--text", help="Comment text (Markdown)"),
+    file: Optional[str] = typer.Option(None, "--file", help="Path to Markdown file for comment body"),
+) -> None:
+    """Add a comment to a Confluence page."""
+    with command_context("comment.add", target={"page_id": page_id}) as ctx:
+        if not text and not file:
+            raise ConfpubError(
+                "ERR_VALIDATION_REQUIRED",
+                "Either --text or --file is required",
+            )
+        if text and file:
+            raise ConfpubError(
+                "ERR_VALIDATION_REQUIRED",
+                "--text and --file are mutually exclusive",
+            )
+
+        if file:
+            from pathlib import Path
+            p = Path(file)
+            if not p.exists():
+                from confpub.errors import ERR_IO_FILE_NOT_FOUND
+                raise ConfpubError(ERR_IO_FILE_NOT_FOUND, f"File not found: {file}")
+            md_text = p.read_text(encoding="utf-8")
+        else:
+            md_text = text
+
+        from confpub.converter import convert_markdown
+        storage_body = convert_markdown(md_text)
+
+        from confpub.confluence import build_client
+        client = build_client()
+        result = client.add_comment(page_id, storage_body)
+        ctx.result = result
+
+
 # ---------------------------------------------------------------------------
 # search command (top-level, not in a subgroup)
 # ---------------------------------------------------------------------------

{confpub_cli-1.1.0 → confpub_cli-1.3.0}/confpub/confluence.py

@@ -267,7 +267,8 @@ class ConfluenceClient:
                 raw = result
             else:
                 raw = []
-            return [_slim_space(s) for s in raw]
+            base_url = self._config.base_url.rstrip("/") if self._config.base_url else ""
+            return [_slim_space(s, base_url=base_url, is_cloud=self._config.is_cloud) for s in raw]
         except Exception as exc:
             self._handle_error(exc, "list_spaces")
             return []
@@ -407,7 +408,7 @@ class ConfluenceClient:
         api_limit = raw.get("limit", limit) if isinstance(raw, dict) else limit
 
         results = [
-            _slim_search_result(r, base_url=base_url, excerpt_length=excerpt_length)
+            _slim_search_result(r, base_url=base_url, is_cloud=self._config.is_cloud, excerpt_length=excerpt_length)
             for r in results_raw
         ]
         return {
@@ -418,6 +419,95 @@ class ConfluenceClient:
             "has_more": (api_start + api_limit) < total,
         }
 
+    # ------------------------------------------------------------------
+    # Label operations
+    # ------------------------------------------------------------------
+
+    def get_labels(self, page_id: str) -> list[dict[str, Any]]:
+        """Get labels on a page."""
+        self._call_count += 1
+        try:
+            result = self._api.get_page_labels(page_id)
+            raw = result.get("results", []) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+            return [_slim_label(lbl) for lbl in raw]
+        except Exception as exc:
+            self._handle_error(exc, "get_labels")
+            return []
+
+    def set_labels(self, page_id: str, labels: list[str]) -> list[dict[str, Any]]:
+        """Set labels on a page (additive — does not remove existing labels)."""
+        results: list[dict[str, Any]] = []
+        for lbl in labels:
+            self._call_count += 1
+            try:
+                result = self._api.set_page_label(page_id, lbl)
+                if isinstance(result, dict):
+                    results.append(_slim_label(result))
+                elif isinstance(result, list):
+                    results.extend(_slim_label(r) for r in result)
+            except Exception as exc:
+                self._handle_error(exc, "set_labels")
+        return results
+
+    def remove_label(self, page_id: str, label: str) -> dict[str, Any]:
+        """Remove a label from a page."""
+        self._call_count += 1
+        try:
+            self._api.remove_page_label(page_id, label)
+            return {"removed": True, "label": label, "page_id": page_id}
+        except Exception as exc:
+            self._handle_error(exc, "remove_label")
+            return {}
+
+    # ------------------------------------------------------------------
+    # Comment operations
+    # ------------------------------------------------------------------
+
+    def add_comment(self, page_id: str, body: str) -> dict[str, Any]:
+        """Add a comment to a page."""
+        self._call_count += 1
+        try:
+            result = self._api.add_comment(page_id, body)
+            return {
+                "id": result.get("id") if isinstance(result, dict) else None,
+                "page_id": page_id,
+                "created": True,
+            }
+        except Exception as exc:
+            self._handle_error(exc, "add_comment")
+            return {}
+
+    # ------------------------------------------------------------------
+    # Page move
+    # ------------------------------------------------------------------
+
+    def move_page(
+        self,
+        space_key: str,
+        page_id: str,
+        target_title: str | None = None,
+        target_id: str | None = None,
+        position: str = "append",
+    ) -> dict[str, Any]:
+        """Move a page under a new parent."""
+        self._call_count += 1
+        try:
+            result = self._api.move_page(
+                space_key, page_id,
+                target_title=target_title,
+                target_id=target_id,
+                position=position,
+            )
+            return {
+                "moved": True,
+                "page_id": page_id,
+                "target_parent": target_title or target_id,
+                "result": result if isinstance(result, dict) else {"raw": str(result)},
+            }
+        except Exception as exc:
+            self._handle_error(exc, "move_page")
+            return {}
+
     # ------------------------------------------------------------------
     # Fingerprinting
     # ------------------------------------------------------------------
@@ -433,7 +523,30 @@ class ConfluenceClient:
             return None
 
 
-def _slim_page(page: dict[str, Any], *, base_url: str = "") -> dict[str, Any]:
+def _webui_base(base_url: str, is_cloud: bool) -> str:
+    """Return the correct base URL for webui links.
+
+    Cloud instances need ``/wiki`` in the path; DC/Server do not.
+    Handles base_url configured with or without the ``/wiki`` suffix.
+    """
+    base = base_url.rstrip("/")
+    if is_cloud and not base.endswith("/wiki"):
+        base += "/wiki"
+    return base
+
+
+def build_page_url(
+    base_url: str, is_cloud: bool, space: str, page_id: str, title: str = "",
+) -> str:
+    """Construct a full webui URL for a Confluence page."""
+    base = _webui_base(base_url, is_cloud)
+    if title:
+        encoded_title = title.replace(" ", "+")
+        return f"{base}/spaces/{space}/pages/{page_id}/{encoded_title}"
+    return f"{base}/spaces/{space}/pages/{page_id}"
+
+
+def _slim_page(page: dict[str, Any], *, base_url: str = "", is_cloud: bool = False) -> dict[str, Any]:
     """Extract agent-relevant fields from a raw Confluence page object."""
     result: dict[str, Any] = {
         "id": page.get("id"),
@@ -456,12 +569,12 @@ def _slim_page(page: dict[str, Any], *, base_url: str = "") -> dict[str, Any]:
         result["parent_title"] = parent.get("title")
     links = page.get("_links", {})
     if "webui" in links:
-        base = base_url or links.get("base", "")
+        base = _webui_base(base_url, is_cloud) if base_url else links.get("base", "")
         result["webui"] = base + links["webui"]
     return result
 
 
-def _slim_space(space: dict[str, Any]) -> dict[str, Any]:
+def _slim_space(space: dict[str, Any], *, base_url: str = "", is_cloud: bool = False) -> dict[str, Any]:
     """Extract agent-relevant fields from a raw Confluence space object."""
     result: dict[str, Any] = {
         "id": space.get("id"),
@@ -478,7 +591,12 @@ def _slim_space(space: dict[str, Any]) -> dict[str, Any]:
                 result["description"] = value
     links = space.get("_links", {})
     if "webui" in links:
-        result["webui"] = links.get("webui", "")
+        webui_path = links.get("webui", "")
+        if base_url and webui_path:
+            base = _webui_base(base_url, is_cloud)
+            result["webui"] = base + webui_path
+        else:
+            result["webui"] = webui_path
     return result
 
 
@@ -507,10 +625,20 @@ def _slim_attachment(att: dict[str, Any]) -> dict[str, Any]:
     return result
 
 
+def _slim_label(lbl: dict[str, Any]) -> dict[str, Any]:
+    """Extract agent-relevant fields from a raw Confluence label object."""
+    return {
+        "name": lbl.get("name", ""),
+        "prefix": lbl.get("prefix", "global"),
+        "id": lbl.get("id"),
+    }
+
+
 def _slim_search_result(
     item: dict[str, Any],
     *,
     base_url: str = "",
+    is_cloud: bool = False,
     excerpt_length: int = 0,
 ) -> dict[str, Any]:
     """Extract agent-relevant fields from a raw Confluence search result.
@@ -536,7 +664,7 @@ def _slim_search_result(
 
         webui = content.get("_links", {}).get("webui", "")
         if webui:
-            _set("url", base_url + webui)
+            _set("url", _webui_base(base_url, is_cloud) + webui if base_url else webui)
 
         _set("space_key", content.get("space", {}).get("key"))
 

{confpub_cli-1.1.0 → confpub_cli-1.3.0}/confpub/errors.py

@@ -15,6 +15,7 @@ ERR_VALIDATION_MARKDOWN = "ERR_VALIDATION_MARKDOWN"
 ERR_VALIDATION_ASSET_MISSING = "ERR_VALIDATION_ASSET_MISSING"
 ERR_VALIDATION_SPACE_MISMATCH = "ERR_VALIDATION_SPACE_MISMATCH"
 ERR_VALIDATION_NOT_FOUND = "ERR_VALIDATION_NOT_FOUND"
+ERR_VALIDATION_LABEL = "ERR_VALIDATION_LABEL"
 
 # Auth (exit 20)
 ERR_AUTH_REQUIRED = "ERR_AUTH_REQUIRED"

{confpub_cli-1.1.0 → confpub_cli-1.3.0}/confpub/guide.py

@@ -24,6 +24,7 @@ from confpub.errors import (
     ERR_IO_FILE_NOT_FOUND,
     ERR_IO_TIMEOUT,
     ERR_VALIDATION_ASSET_MISSING,
+    ERR_VALIDATION_LABEL,
     ERR_VALIDATION_MANIFEST,
     ERR_VALIDATION_MARKDOWN,
     ERR_VALIDATION_NOT_FOUND,
@@ -121,11 +122,23 @@ def build_guide() -> dict[str, Any]:
                 "group": "write",
                 "mutates": True,
                 "description": "Publish a single Markdown file to Confluence",
-                "flags": ["--space", "--parent", "--title", "--page-id", "--dry-run", "--backup"],
+                "flags": ["--space", "--parent", "--title", "--page-id", "--dry-run", "--backup", "--label"],
                 "agent_hint": (
                     "When --title is omitted, the title is inferred from the filename: "
                     "the stem is extracted, hyphens and underscores are replaced with spaces, "
-                    "and the result is title-cased. E.g. 'my-cool-page.md' → 'My Cool Page'."
+                    "and the result is title-cased. E.g. 'my-cool-page.md' → 'My Cool Page'. "
+                    "Use --label to apply labels (repeatable): --label api --label docs."
+                ),
+            },
+            "page.move": {
+                "group": "write",
+                "mutates": True,
+                "description": "Move a page under a new parent",
+                "flags": ["--page-id", "--target-parent", "--space", "--target-parent-id"],
+                "agent_hint": (
+                    "Use --target-parent + --space for title-based targeting, "
+                    "or --target-parent-id for ID-based targeting. "
+                    "The page ID does not change after a move."
                 ),
             },
             "page.pull": {
@@ -177,6 +190,32 @@ def build_guide() -> dict[str, Any]:
                 "description": "Upload an attachment to a Confluence page",
                 "flags": ["--page-id"],
             },
+            "label.list": {
+                "group": "read",
+                "mutates": False,
+                "description": "List labels on a Confluence page",
+                "flags": ["--page-id"],
+            },
+            "label.add": {
+                "group": "write",
+                "mutates": True,
+                "description": "Add labels to a Confluence page",
+                "flags": ["--page-id", "--label"],
+                "agent_hint": "Use --label for each label (repeatable): --label api --label docs. Labels must not contain spaces and max 255 characters.",
+            },
+            "label.remove": {
+                "group": "write",
+                "mutates": True,
+                "description": "Remove labels from a Confluence page",
+                "flags": ["--page-id", "--label"],
+            },
+            "comment.add": {
+                "group": "write",
+                "mutates": True,
+                "description": "Add a comment to a Confluence page",
+                "flags": ["--page-id", "--text", "--file"],
+                "agent_hint": "Exactly one of --text or --file is required. The body is converted from Markdown to Confluence storage format.",
+            },
             "plan.create": {
                 "group": "transactional",
                 "mutates": False,
@@ -254,6 +293,7 @@ def build_guide() -> dict[str, Any]:
             ERR_VALIDATION_ASSET_MISSING: _error_code_entry(ERR_VALIDATION_ASSET_MISSING),
             ERR_VALIDATION_NOT_FOUND: _error_code_entry(ERR_VALIDATION_NOT_FOUND),
             ERR_VALIDATION_SPACE_MISMATCH: _error_code_entry(ERR_VALIDATION_SPACE_MISMATCH),
+            ERR_VALIDATION_LABEL: _error_code_entry(ERR_VALIDATION_LABEL),
             ERR_AUTH_REQUIRED: _error_code_entry(ERR_AUTH_REQUIRED),
             ERR_AUTH_EXPIRED: _error_code_entry(ERR_AUTH_EXPIRED),
             ERR_AUTH_FORBIDDEN: _error_code_entry(ERR_AUTH_FORBIDDEN),

{confpub_cli-1.1.0 → confpub_cli-1.3.0}/confpub/manifest.py

@@ -51,6 +51,7 @@ class ManifestPage(BaseModel):
     title: str
     file: str
     assets: list[str] = Field(default_factory=list)
+    labels: list[str] = Field(default_factory=list)
     children: list[ManifestPage] = Field(default_factory=list)
 
 
@@ -93,6 +94,7 @@ class PlanPage(BaseModel):
     operation: Literal["create", "update", "noop"]
     parent_title: Optional[str] = None
     attachments: list[PlanAttachment] = Field(default_factory=list)
+    labels: list[str] = Field(default_factory=list)
 
 
 class PlanSummary(BaseModel):
@@ -102,6 +104,7 @@ class PlanSummary(BaseModel):
     update: int = 0
     noop: int = 0
     attachments_to_upload: int = 0
+    labels_to_apply: int = 0
 
 
 class PlanArtifact(BaseModel):
@@ -126,6 +129,7 @@ class FlatPage(BaseModel):
     title: str
     file: str
     assets: list[str] = Field(default_factory=list)
+    labels: list[str] = Field(default_factory=list)  # merged global + per-page
     parent_title: str  # The parent page title (from manifest parent or parent page)
 
 
@@ -187,6 +191,9 @@ def generate_manifest_yaml(
         result = []
         for p in pages:
             entry: dict[str, Any] = {"title": p["title"], "file": p["file"]}
+            labels = p.get("labels", [])
+            if labels:
+                entry["labels"] = labels
             children = p.get("children", [])
             if children:
                 entry["children"] = _build_pages(children)
@@ -206,16 +213,20 @@ def resolve_page_tree(manifest: Manifest) -> list[FlatPage]:
     """Flatten the recursive page tree into a list with parent references.
 
     Pages are returned in tree order (parents before children) to ensure
-    correct creation order.
+    correct creation order. Labels are merged: global (manifest.labels)
+    first, then per-page, deduplicated while preserving order.
     """
     flat: list[FlatPage] = []
+    global_labels = manifest.labels
 
     def _walk(pages: list[ManifestPage], parent_title: str) -> None:
         for page in pages:
+            merged = list(dict.fromkeys(global_labels + page.labels))
             flat.append(FlatPage(
                 title=page.title,
                 file=page.file,
                 assets=page.assets,
+                labels=merged,
                 parent_title=parent_title,
             ))
             if page.children:

{confpub_cli-1.1.0 → confpub_cli-1.3.0}/confpub/planner.py

@@ -58,7 +58,7 @@ def create_plan(
 
     # Build plan pages
     plan_pages: list[PlanPage] = []
-    counts = {"create": 0, "update": 0, "noop": 0, "attachments_to_upload": 0}
+    counts = {"create": 0, "update": 0, "noop": 0, "attachments_to_upload": 0, "labels_to_apply": 0}
 
     for i, fp in enumerate(flat_pages):
         plan_id = f"plan_{i + 1}"
@@ -118,6 +118,8 @@ def create_plan(
 
         counts[operation] += 1
         counts["attachments_to_upload"] += len(plan_attachments)
+        if fp.labels:
+            counts["labels_to_apply"] += len(fp.labels)
 
         plan_pages.append(PlanPage(
             id=plan_id,
@@ -128,6 +130,7 @@ def create_plan(
             operation=operation,
             parent_title=fp.parent_title,
             attachments=plan_attachments,
+            labels=fp.labels,
         ))
 
     # Build plan artifact