confpub-cli 0.8.0__tar.gz → 1.0.0__tar.gz

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/PKG-INFO

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

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

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/confpub/applier.py

@@ -14,7 +14,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.converter import convert_markdown
+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
 from confpub.manifest import PlanArtifact
@@ -126,6 +126,7 @@ def apply_plan(
 
                 # Update lockfile and parent tracking
                 update_lockfile(lockfile, page.title, new_id, new_version if isinstance(new_version, int) else 1)
+                lockfile.pages[page.title].content_fingerprint = fingerprint_content(storage)
                 parent_ids[page.title] = new_id
 
             counts["create"] += 1
@@ -180,6 +181,7 @@ def apply_plan(
                     lockfile, page.title, page.confluence_page_id,
                     new_version if isinstance(new_version, int) else 1,
                 )
+                lockfile.pages[page.title].content_fingerprint = fingerprint_content(storage)
                 parent_ids[page.title] = page.confluence_page_id
 
             counts["update"] += 1
@@ -193,4 +195,5 @@ def apply_plan(
         "dry_run": dry_run,
         "changes": changes,
         "summary": counts,
+        "lockfile_updated": not dry_run and len(changes) > 0,
     }

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/confpub/cli.py

@@ -171,12 +171,14 @@ def command_context(command_name: str, target: dict[str, Any] | None = None) ->
 @page_app.command("list")
 def page_list(
     space: str = typer.Option(..., "--space", help="Confluence space key"),
+    limit: int = typer.Option(25, "--limit", help="Maximum number of pages to return"),
+    start: int = typer.Option(0, "--start", help="Starting offset for pagination"),
 ) -> None:
     """List pages in a Confluence space."""
     with command_context("page.list", target={"space": space}) as ctx:
         from confpub.confluence import build_client, _slim_page
         client = build_client()
-        pages = client.list_pages(space)
+        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]}
 
 
@@ -235,6 +237,12 @@ def page_publish(
     if page_id:
         target["page_id"] = page_id
     with command_context("page.publish", target=target) as ctx:
+        from pathlib import Path as _Path
+        if not _Path(file).exists():
+            raise ConfpubError(
+                "ERR_IO_FILE_NOT_FOUND",
+                f"File not found: {file}",
+            )
         if not page_id and not parent:
             raise ConfpubError(
                 "ERR_VALIDATION_REQUIRED",
@@ -307,12 +315,54 @@ def page_delete(
             )
         from confpub.confluence import build_client
         client = build_client()
+
+        # Collect page IDs that will be deleted (for lockfile cleanup)
+        deleted_ids: set[str] = set()
         if page_id:
             if cascade:
+                # Collect descendant IDs before deleting
+                def _collect_ids(pid: str) -> None:
+                    children = client.get_page_children(pid)
+                    for child in children:
+                        cid = str(child["id"])
+                        deleted_ids.add(cid)
+                        _collect_ids(cid)
+                _collect_ids(page_id)
                 client._delete_descendants(page_id)
+            deleted_ids.add(page_id)
             result = client.delete_page(page_id)
         else:
+            if cascade:
+                page = client.get_page(space, title)
+                if page:
+                    pid = str(page["id"])
+                    def _collect_ids_by_title(p: str) -> None:
+                        children = client.get_page_children(p)
+                        for child in children:
+                            cid = str(child["id"])
+                            deleted_ids.add(cid)
+                            _collect_ids_by_title(cid)
+                    _collect_ids_by_title(pid)
+                    deleted_ids.add(pid)
             result = client.delete_page_by_title(space, title, cascade=cascade)
+
+        # Clean up lockfile entries for deleted pages
+        from pathlib import Path
+        from confpub.lockfile import Lockfile, load_lockfile, save_lockfile, remove_from_lockfile
+        lockfile_path = Path.cwd() / "confpub.lock"
+        lockfile = load_lockfile(lockfile_path)
+        if lockfile:
+            removed = False
+            if title and not page_id:
+                removed = remove_from_lockfile(lockfile, title) or removed
+            # Remove entries matching any deleted page ID
+            for lf_title, entry in list(lockfile.pages.items()):
+                if entry.page_id in deleted_ids:
+                    remove_from_lockfile(lockfile, lf_title)
+                    removed = True
+            if removed:
+                save_lockfile(lockfile_path, lockfile)
+
         ctx.result = result
 
 
@@ -494,6 +544,10 @@ def search(
             excerpt_length=excerpt_length,
         )
         result["cql_query"] = effective_cql
+        if space and result.get("total", 0) == 0:
+            ctx.warnings.append(
+                f"No results found. Verify space '{space}' exists (use 'space list' to check)."
+            )
         ctx.result = result
 
 

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/confpub/confluence.py

@@ -262,11 +262,13 @@ class ConfluenceClient:
             self._handle_error(exc, "list_spaces")
             return []
 
-    def list_pages(self, space: str) -> list[dict[str, Any]]:
+    def list_pages(self, space: str, *, start: int = 0, limit: int = 25) -> list[dict[str, Any]]:
         """List pages in a space."""
         self._call_count += 1
         try:
-            result = self._api.get_all_pages_from_space(space, expand="version")
+            result = self._api.get_all_pages_from_space(
+                space, start=start, limit=limit, expand="version",
+            )
             return result if isinstance(result, list) else []
         except Exception as exc:
             self._handle_error(exc, "list_pages")

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/confpub/guide.py

@@ -86,7 +86,7 @@ def build_guide() -> dict[str, Any]:
                 "group": "read",
                 "mutates": False,
                 "description": "List pages in a Confluence space",
-                "flags": ["--space"],
+                "flags": ["--space", "--limit", "--start"],
             },
             "page.inspect": {
                 "group": "read",
@@ -244,6 +244,7 @@ def build_guide() -> dict[str, Any]:
             },
             "behavior": [
                 "Created/updated automatically by page.publish, page.pull, and plan.apply",
+                "Entries removed automatically by page.delete (including --cascade)",
                 "Written atomically (temp file + rename) for crash safety",
                 "Used by plan.create to detect existing pages and versions",
                 "Does not prevent concurrent operations — purely local state tracking",

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/confpub/lockfile.py

@@ -90,3 +90,14 @@ def update_lockfile(
     """Update a page entry in the lockfile."""
     lockfile.pages[title] = LockPageEntry(page_id=page_id, version=version)
     return lockfile
+
+
+def remove_from_lockfile(lockfile: Lockfile, title: str) -> bool:
+    """Remove a page entry from the lockfile by title.
+
+    Returns True if the entry was found and removed, False otherwise.
+    """
+    if title in lockfile.pages:
+        del lockfile.pages[title]
+        return True
+    return False

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/confpub/puller.py

@@ -130,8 +130,8 @@ def _check_conflicts(file_paths: dict[str, str], force: bool) -> None:
             ERR_CONFLICT_FILE_EXISTS,
             f"Output files already exist: {', '.join(existing[:5])}"
             + (f" (and {len(existing) - 5} more)" if len(existing) > 5 else ""),
-            details={"existing_files": existing},
-            suggested_action="fix_input",
+            details={"existing_files": existing, "hint": "Use --force to overwrite existing files"},
+            suggested_action="retry_with_flag",
         )
 
 

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/tests/test_applier.py

@@ -127,6 +127,42 @@ class TestApplyPlanReal:
         assert "Existing Page" in lock_data["pages"]
 
 
+class TestApplyLockfileFingerprints:
+    @patch("confpub.applier.load_config")
+    @patch("confpub.applier.ConfluenceClient")
+    def test_lockfile_entries_have_fingerprints(self, MockClient, mock_config, plan_dir, mock_client):
+        MockClient.return_value = mock_client
+        mock_config.return_value = MagicMock()
+
+        result = apply_plan(str(plan_dir / "plan.json"), dry_run=False)
+
+        lockfile_path = plan_dir / "confpub.lock"
+        assert lockfile_path.exists()
+        lock_data = json.loads(lockfile_path.read_text())
+        for title in ("New Page", "Existing Page"):
+            entry = lock_data["pages"][title]
+            assert entry["content_fingerprint"] is not None, f"{title} has null fingerprint"
+            assert len(entry["content_fingerprint"]) == 64  # SHA-256 hex digest
+
+    @patch("confpub.applier.load_config")
+    @patch("confpub.applier.ConfluenceClient")
+    def test_lockfile_updated_in_result(self, MockClient, mock_config, plan_dir, mock_client):
+        MockClient.return_value = mock_client
+        mock_config.return_value = MagicMock()
+
+        result = apply_plan(str(plan_dir / "plan.json"), dry_run=False)
+        assert result["lockfile_updated"] is True
+
+    @patch("confpub.applier.load_config")
+    @patch("confpub.applier.ConfluenceClient")
+    def test_lockfile_updated_false_on_dry_run(self, MockClient, mock_config, plan_dir, mock_client):
+        MockClient.return_value = mock_client
+        mock_config.return_value = MagicMock()
+
+        result = apply_plan(str(plan_dir / "plan.json"), dry_run=True)
+        assert result["lockfile_updated"] is False
+
+
 class TestFingerprintCheck:
     @patch("confpub.applier.load_config")
     @patch("confpub.applier.ConfluenceClient")

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/tests/test_integration.py

@@ -110,7 +110,7 @@ class TestPersonalSpaceKeyCLI:
         """--space ~thro must arrive as literal '~thro' in the command handler."""
         captured = {}
 
-        def fake_list_pages(self, space):
+        def fake_list_pages(self, space, **kwargs):
             captured["space"] = space
             return []
 

{confpub_cli-0.8.0 → confpub_cli-1.0.0}/tests/test_lockfile.py

@@ -8,6 +8,7 @@ from confpub.lockfile import (
     LockPageEntry,
     Lockfile,
     load_lockfile,
+    remove_from_lockfile,
     save_lockfile,
     update_lockfile,
 )
@@ -110,3 +111,35 @@ class TestUpdateLockfile:
         update_lockfile(lf, "A", "1", 2)
         assert lf.pages["B"].page_id == "2"
         assert lf.pages["B"].version == 1
+
+
+class TestRemoveFromLockfile:
+    def test_remove_existing_entry(self):
+        lf = Lockfile(pages={
+            "A": LockPageEntry(page_id="1", version=1),
+            "B": LockPageEntry(page_id="2", version=2),
+        })
+        result = remove_from_lockfile(lf, "A")
+        assert result is True
+        assert "A" not in lf.pages
+        assert "B" in lf.pages
+
+    def test_remove_nonexistent_entry(self):
+        lf = Lockfile(pages={
+            "A": LockPageEntry(page_id="1", version=1),
+        })
+        result = remove_from_lockfile(lf, "Missing")
+        assert result is False
+        assert "A" in lf.pages
+
+    def test_remove_from_empty_lockfile(self):
+        lf = Lockfile()
+        result = remove_from_lockfile(lf, "Anything")
+        assert result is False
+
+    def test_remove_all_entries(self):
+        lf = Lockfile(pages={
+            "A": LockPageEntry(page_id="1", version=1),
+        })
+        remove_from_lockfile(lf, "A")
+        assert len(lf.pages) == 0