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

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

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

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

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

@@ -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
@@ -128,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)
@@ -184,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.2.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:
@@ -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.2.0 → confpub_cli-1.3.0}/confpub/confluence.py

@@ -419,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
     # ------------------------------------------------------------------
@@ -536,6 +625,15 @@ 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],
     *,

{confpub_cli-1.2.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.2.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.2.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.2.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

{confpub_cli-1.2.0 → confpub_cli-1.3.0}/confpub/publish.py

@@ -39,6 +39,7 @@ def publish_page(
     dry_run: bool = False,
     backup: bool = False,
     progress_callback: Any = None,
+    labels: list[str] | None = None,
 ) -> dict[str, Any]:
     """Publish a single Markdown file to Confluence.
 
@@ -129,6 +130,8 @@ def publish_page(
         }
         if assets:
             change["attachments_to_upload"] = [a.source_path for a in assets]
+        if labels:
+            change["labels_to_apply"] = labels
 
         warnings: list[str] = []
         parent_page = client.get_page(space, parent)
@@ -146,14 +149,19 @@ def publish_page(
 
     # Real publish
     if operation == "noop":
+        noop_change: dict[str, Any] = {
+            "type": "page.noop",
+            "title": page_title,
+            "confluence_page_id": existing_page_id,
+            "before": {"version": current_version} if current_version else None,
+        }
+        # Labels may still need applying even when content is unchanged
+        if labels and existing_page_id:
+            client.set_labels(existing_page_id, labels)
+            noop_change["labels_added"] = labels
         return {
             "dry_run": False,
-            "changes": [{
-                "type": "page.noop",
-                "title": page_title,
-                "confluence_page_id": existing_page_id,
-                "before": {"version": current_version} if current_version else None,
-            }],
+            "changes": [noop_change],
             "summary": {"noop": 1},
         }
 
@@ -192,6 +200,10 @@ def publish_page(
         client.update_page(page_id, page_title, storage)
         uploaded_attachments = [a.source_path for a in assets]
 
+    # Apply labels
+    if labels:
+        client.set_labels(page_id, labels)
+
     # Update lockfile
     new_version_int = new_version if isinstance(new_version, int) else 1
     update_lockfile(lockfile, page_title, page_id, new_version_int, content_fingerprint=local_fingerprint)
@@ -215,6 +227,8 @@ def publish_page(
         change["backup_path"] = backup_file_path
     if uploaded_attachments:
         change["attachments_added"] = uploaded_attachments
+    if labels:
+        change["labels_added"] = labels
 
     return {
         "dry_run": False,

{confpub_cli-1.2.0 → confpub_cli-1.3.0}/confpub/puller.py

@@ -187,10 +187,12 @@ def _build_page_tree(
     file_paths: dict[str, str],
     root_page_id: str,
     output_dir: str = ".",
+    page_labels: 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 {}
 
     for entry in pages:
         page = entry["page"]
@@ -198,11 +200,14 @@ def _build_page_tree(
         parent_id = str(entry["parent_id"]) if entry["parent_id"] else None
         file_path = file_paths.get(pid, "")
 
-        id_to_entry[pid] = {
+        node: dict[str, Any] = {
             "title": page.get("title", ""),
             "file": os.path.relpath(file_path, output_dir) if file_path else "",
             "children": [],
         }
+        if labels_map.get(pid):
+            node["labels"] = labels_map[pid]
+        id_to_entry[pid] = node
         children_map.setdefault(parent_id, []).append(pid)
 
     def _attach_children(parent_id: str) -> list[dict[str, Any]]:
@@ -300,12 +305,16 @@ def pull_pages(
         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)]
+
         files_result.append({
             "page_id": pid,
             "title": page_title,
             "file": out_path,
             "version": version_num,
             "attachments_downloaded": attachments_downloaded,
+            "labels": page_labels,
         })
 
     # Generate manifest if requested or recursive with multiple pages
@@ -315,7 +324,11 @@ def pull_pages(
         # 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
-        page_tree = _build_page_tree(all_pages, file_paths, root_id, output_dir)
+        # 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")