wagapi 0.2.2__tar.gz → 0.3.0__tar.gz

{wagapi-0.2.2 → wagapi-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wagapi
-Version: 0.2.2
+Version: 0.3.0
 Summary: CLI client for the Wagtail Write API, optimised for LLM orchestration
 Project-URL: Repository, https://github.com/tomdyson/wagapi
 Project-URL: Issues, https://github.com/tomdyson/wagapi/issues
@@ -64,10 +64,10 @@ uv tool install wagapi
 
 ### 1. Set up a Wagtail site with wagtail-write-api
 
-Follow the [example app guide](https://tomdyson.github.io/wagtail-write-api/development/example-app/) to get a local Wagtail instance running:
+Follow the [example app guide](https://tomdyson.github.io/wagtail-write-api/development/example-app/) to get a local Wagtail instance running with [wagtail-write-api](https://github.com/tomdyson/wagtail-write-api):
 
 ```bash
-cd example
+cd wagtail-write-api/example
 uv run python manage.py migrate
 uv run python manage.py seed_demo
 uv run python manage.py runserver
@@ -168,7 +168,7 @@ wagapi pages delete <ID>
 wagapi -v pages get <ID>
 
 # Preview without executing
-wagapi --dry-run pages create testapp.SimplePage --parent /home/ --title "Test"
+wagapi --dry-run pages create testapp.SimplePage --parent / --title "Test"
 ```
 
 ### 8. Pipe-friendly JSON output
@@ -255,8 +255,8 @@ wagapi pages list [OPTIONS]
 | Option | Description |
 |---|---|
 | `--type TYPE` | Filter by page type, e.g. `testapp.BlogPage` |
-| `--parent ID` | Direct children of page ID |
-| `--descendant-of ID` | All descendants of page ID |
+| `--parent ID_OR_PATH` | Direct children of page ID or URL path (e.g. `5` or `/blog/`) |
+| `--descendant-of ID_OR_PATH` | All descendants of page ID or URL path |
 | `--status STATUS` | `draft`, `live`, or `live+draft` |
 | `--slug SLUG` | Exact slug match |
 | `--path PATH` | Exact URL path match, e.g. `/blog/my-post/` |
@@ -288,7 +288,9 @@ wagapi pages create <type> --parent ID_OR_PATH --title TITLE [OPTIONS]
 | `--publish` | Publish immediately (default: create as draft) |
 | `--raw` | Treat field values as raw JSON (no auto-wrapping) |
 
-**Markdown body (auto-converted to StreamField):**
+**Markdown body (auto-detected: StreamField blocks or RichTextField HTML):**
+
+`--body` checks the page type schema to determine the field type. For StreamField fields, markdown is converted to blocks. For RichTextField fields, markdown is sent as-is for server-side conversion to HTML.
 
 ```bash
 wagapi pages create testapp.BlogPage --parent /blog/ \

{wagapi-0.2.2 → wagapi-0.3.0}/README.md

@@ -34,10 +34,10 @@ uv tool install wagapi
 
 ### 1. Set up a Wagtail site with wagtail-write-api
 
-Follow the [example app guide](https://tomdyson.github.io/wagtail-write-api/development/example-app/) to get a local Wagtail instance running:
+Follow the [example app guide](https://tomdyson.github.io/wagtail-write-api/development/example-app/) to get a local Wagtail instance running with [wagtail-write-api](https://github.com/tomdyson/wagtail-write-api):
 
 ```bash
-cd example
+cd wagtail-write-api/example
 uv run python manage.py migrate
 uv run python manage.py seed_demo
 uv run python manage.py runserver
@@ -138,7 +138,7 @@ wagapi pages delete <ID>
 wagapi -v pages get <ID>
 
 # Preview without executing
-wagapi --dry-run pages create testapp.SimplePage --parent /home/ --title "Test"
+wagapi --dry-run pages create testapp.SimplePage --parent / --title "Test"
 ```
 
 ### 8. Pipe-friendly JSON output
@@ -225,8 +225,8 @@ wagapi pages list [OPTIONS]
 | Option | Description |
 |---|---|
 | `--type TYPE` | Filter by page type, e.g. `testapp.BlogPage` |
-| `--parent ID` | Direct children of page ID |
-| `--descendant-of ID` | All descendants of page ID |
+| `--parent ID_OR_PATH` | Direct children of page ID or URL path (e.g. `5` or `/blog/`) |
+| `--descendant-of ID_OR_PATH` | All descendants of page ID or URL path |
 | `--status STATUS` | `draft`, `live`, or `live+draft` |
 | `--slug SLUG` | Exact slug match |
 | `--path PATH` | Exact URL path match, e.g. `/blog/my-post/` |
@@ -258,7 +258,9 @@ wagapi pages create <type> --parent ID_OR_PATH --title TITLE [OPTIONS]
 | `--publish` | Publish immediately (default: create as draft) |
 | `--raw` | Treat field values as raw JSON (no auto-wrapping) |
 
-**Markdown body (auto-converted to StreamField):**
+**Markdown body (auto-detected: StreamField blocks or RichTextField HTML):**
+
+`--body` checks the page type schema to determine the field type. For StreamField fields, markdown is converted to blocks. For RichTextField fields, markdown is sent as-is for server-side conversion to HTML.
 
 ```bash
 wagapi pages create testapp.BlogPage --parent /blog/ \

{wagapi-0.2.2 → wagapi-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wagapi"
-version = "0.2.2"
+version = "0.3.0"
 description = "CLI client for the Wagtail Write API, optimised for LLM orchestration"
 readme = "README.md"
 license = "MIT"

{wagapi-0.2.2 → wagapi-0.3.0}/tests/conftest.py

@@ -51,6 +51,23 @@ SAMPLE_PAGE_TYPE_SCHEMA = {
     },
 }
 
+SAMPLE_RICHTEXT_PAGE_TYPE_SCHEMA = {
+    "name": "home.SimplePage",
+    "verbose_name": "simple page",
+    "create_schema": {
+        "required": ["type", "parent", "title"],
+        "properties": {
+            "type": {"type": "string"},
+            "parent": {"type": "integer"},
+            "title": {"type": "string"},
+            "body": {"type": "string", "description": "RichTextField body content"},
+        },
+    },
+    "allowed_parents": ["wagtailcore.Page"],
+    "allowed_children": [],
+    "streamfield_blocks": {},
+}
+
 SAMPLE_PAGE = {
     "id": 42,
     "title": "Hello",

{wagapi-0.2.2 → wagapi-0.3.0}/tests/test_commands.py

@@ -158,7 +158,12 @@ def test_pages_create(runner):
 
 
 @respx.mock
-def test_pages_create_with_body(runner):
+def test_pages_create_with_body_streamfield(runner):
+    """Body is converted to StreamField blocks when the field is a StreamField."""
+    schema = {"streamfield_blocks": {"body": [{"type": "heading"}, {"type": "paragraph"}]}}
+    respx.get(f"{BASE_URL}/schema/blog.BlogPage/").mock(
+        return_value=Response(200, json=schema)
+    )
     data = {
         "id": 43,
         "title": "Iris",
@@ -179,13 +184,45 @@ def test_pages_create_with_body(runner):
             ],
         )
     assert result.exit_code == 0
-    # Verify the request body contained streamfield blocks
     request_body = json.loads(route.calls[0].request.content)
     assert isinstance(request_body["body"], list)
     assert request_body["body"][0]["type"] == "heading"
     assert request_body["body"][1]["type"] == "paragraph"
 
 
+@respx.mock
+def test_pages_create_with_body_richtext(runner):
+    """Body is sent as richtext format dict when the field is a RichTextField."""
+    schema = {"streamfield_blocks": {}}
+    respx.get(f"{BASE_URL}/schema/home.SimplePage/").mock(
+        return_value=Response(200, json=schema)
+    )
+    data = {
+        "id": 50,
+        "title": "About",
+        "slug": "about",
+        "meta": {"type": "home.SimplePage", "live": False, "parent_id": 3},
+    }
+    route = respx.post(f"{BASE_URL}/pages/").mock(
+        return_value=Response(201, json=data)
+    )
+    with mock.patch.dict("os.environ", ENV):
+        result = runner.invoke(
+            cli,
+            [
+                "pages", "create", "home.SimplePage",
+                "--parent", "3",
+                "--title", "About",
+                "--body", "Hello **world**",
+            ],
+        )
+    assert result.exit_code == 0
+    request_body = json.loads(route.calls[0].request.content)
+    assert isinstance(request_body["body"], dict)
+    assert request_body["body"]["format"] == "markdown"
+    assert request_body["body"]["content"] == "Hello **world**"
+
+
 @respx.mock
 def test_pages_create_with_path_parent(runner):
     data = {
@@ -245,6 +282,33 @@ def test_pages_update(runner):
     assert "Updated" in result.output
 
 
+@respx.mock
+def test_pages_update_with_body_richtext(runner):
+    """Update fetches the page type and sends richtext for RichTextField."""
+    # Mock GET to fetch the page (to learn its type)
+    page_data = {
+        "id": 42, "title": "Old", "body": "<p>old</p>",
+        "meta": {"type": "home.SimplePage", "live": True},
+    }
+    respx.get(f"{BASE_URL}/pages/42/").mock(return_value=Response(200, json=page_data))
+    # Mock schema lookup
+    schema = {"streamfield_blocks": {}}
+    respx.get(f"{BASE_URL}/schema/home.SimplePage/").mock(
+        return_value=Response(200, json=schema)
+    )
+    # Mock PATCH
+    updated = {**page_data, "body": "<p>new</p>"}
+    route = respx.patch(f"{BASE_URL}/pages/42/").mock(
+        return_value=Response(200, json=updated)
+    )
+    with mock.patch.dict("os.environ", ENV):
+        result = runner.invoke(cli, ["pages", "update", "42", "--body", "new content"])
+    assert result.exit_code == 0
+    request_body = json.loads(route.calls[0].request.content)
+    assert isinstance(request_body["body"], dict)
+    assert request_body["body"]["format"] == "markdown"
+
+
 @respx.mock
 def test_pages_delete(runner):
     respx.delete(f"{BASE_URL}/pages/42/").mock(return_value=Response(204))

wagapi-0.3.0/tests/test_formatting.py

@@ -0,0 +1,173 @@
+"""Tests for wagapi.formatting.output — human-readable formatters."""
+
+from wagapi.formatting.output import (
+    _richtext_preview,
+    _streamfield_preview,
+    format_page_detail,
+    format_page_list,
+    format_schema_detail,
+)
+
+
+class TestStreamfieldPreview:
+    def test_heading_and_paragraph(self):
+        blocks = [
+            {"type": "heading", "value": {"text": "Hello", "size": "h2"}},
+            {"type": "paragraph", "value": "<p>World <b>bold</b></p>"},
+        ]
+        assert _streamfield_preview(blocks) == "Hello / World bold"
+
+    def test_plain_text_heading(self):
+        blocks = [{"type": "heading", "value": "Just text"}]
+        assert _streamfield_preview(blocks) == "Just text"
+
+    def test_truncation(self):
+        blocks = [{"type": "paragraph", "value": "<p>" + "x" * 300 + "</p>"}]
+        result = _streamfield_preview(blocks, max_len=50)
+        assert len(result) == 50
+        assert result.endswith("…")
+
+    def test_empty_blocks(self):
+        assert _streamfield_preview([]) == ""
+
+    def test_unknown_block_types_skipped(self):
+        blocks = [{"type": "image", "value": 42}]
+        assert _streamfield_preview(blocks) == ""
+
+
+class TestRichtextPreview:
+    def test_strips_html(self):
+        assert _richtext_preview("<p>Hello <b>world</b></p>") == "Hello world"
+
+    def test_truncation(self):
+        result = _richtext_preview("<p>" + "x" * 300 + "</p>", max_len=50)
+        assert len(result) == 50
+        assert result.endswith("…")
+
+    def test_empty(self):
+        assert _richtext_preview("") == ""
+
+
+class TestFormatPageList:
+    def test_includes_url_path(self):
+        data = {
+            "meta": {"total_count": 1},
+            "items": [
+                {
+                    "id": 6,
+                    "title": "Blog Post",
+                    "meta": {
+                        "type": "blog.BlogPage",
+                        "live": True,
+                        "url_path": "/blog/blog-post/",
+                    },
+                }
+            ],
+        }
+        result = format_page_list(data)
+        assert "/blog/blog-post/" in result
+
+    def test_no_url_path_still_works(self):
+        data = {
+            "meta": {"total_count": 1},
+            "items": [
+                {
+                    "id": 1,
+                    "title": "Root",
+                    "meta": {"type": "wagtailcore.Page", "live": True},
+                }
+            ],
+        }
+        result = format_page_list(data)
+        assert "Root" in result
+
+
+class TestFormatPageDetail:
+    def test_shows_url_path(self):
+        data = {
+            "id": 6,
+            "title": "Blog Post",
+            "slug": "blog-post",
+            "meta": {
+                "type": "blog.BlogPage",
+                "live": True,
+                "url_path": "/blog/blog-post/",
+                "parent_id": 5,
+            },
+        }
+        result = format_page_detail(data)
+        assert "Path: /blog/blog-post/" in result
+
+    def test_streamfield_body_preview(self):
+        data = {
+            "id": 6,
+            "title": "Post",
+            "slug": "post",
+            "meta": {"type": "blog.BlogPage", "live": True},
+            "body": [
+                {"type": "heading", "value": {"text": "Intro", "size": "h2"}},
+                {"type": "paragraph", "value": "<p>Some content here.</p>"},
+            ],
+        }
+        result = format_page_detail(data)
+        assert "body: Intro / Some content here." in result
+
+    def test_richtext_body_preview(self):
+        data = {
+            "id": 4,
+            "title": "About",
+            "slug": "about",
+            "meta": {"type": "home.SimplePage", "live": True},
+            "body": "<p>About us page content</p>",
+        }
+        result = format_page_detail(data)
+        assert "body: About us page content" in result
+
+
+class TestFormatSchemaDetail:
+    def test_streamfield_type_annotation(self):
+        data = {
+            "type": "blog.BlogPage",
+            "create_schema": {
+                "required": ["body"],
+                "properties": {
+                    "body": {"type": "array", "title": "Body"},
+                },
+            },
+            "streamfield_blocks": {"body": [{"type": "paragraph"}]},
+            "richtext_fields": [],
+        }
+        result = format_schema_detail(data)
+        assert "StreamField" in result
+
+    def test_richtext_type_annotation(self):
+        data = {
+            "type": "home.SimplePage",
+            "create_schema": {
+                "required": [],
+                "properties": {
+                    "body": {"type": "string", "title": "Body"},
+                },
+            },
+            "streamfield_blocks": {},
+            "richtext_fields": ["body"],
+        }
+        result = format_schema_detail(data)
+        assert "RichText" in result
+
+    def test_regular_string_not_annotated(self):
+        data = {
+            "type": "blog.BlogPage",
+            "create_schema": {
+                "required": [],
+                "properties": {
+                    "slug": {"type": "string", "title": "Slug"},
+                },
+            },
+            "streamfield_blocks": {},
+            "richtext_fields": [],
+        }
+        result = format_schema_detail(data)
+        assert "RichText" not in result
+        assert "StreamField" not in result
+        assert "string" in result

wagapi-0.3.0/wagapi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

{wagapi-0.2.2 → wagapi-0.3.0}/wagapi/cli.py

@@ -52,7 +52,8 @@ def handle_api_errors(fn):
     return wrapper
 
 
-@click.group()
+@click.group(invoke_without_command=True)
+@click.version_option(package_name="wagapi")
 @click.option("--url", envvar="WAGAPI_URL", default=None, help="API base URL")
 @click.option("--token", envvar="WAGAPI_TOKEN", default=None, help="API token")
 @click.option("--json", "output_json", is_flag=True, help="Force JSON output")
@@ -62,6 +63,10 @@ def handle_api_errors(fn):
 @click.pass_context
 def cli(ctx: click.Context, url, token, output_json, output_human, verbose, dry_run):
     """wagapi — CLI client for the Wagtail Write API."""
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+        return
+
     obj = Context()
     obj.force_json = output_json
     obj.force_human = output_human

{wagapi-0.2.2 → wagapi-0.3.0}/wagapi/commands/pages.py

@@ -7,7 +7,7 @@ import click
 
 from wagapi.cli import Context, handle_api_errors, pass_ctx
 from wagapi.exceptions import UsageError
-from wagapi.formatting.markdown import markdown_to_streamfield
+from wagapi.formatting.markdown import markdown_to_richtext, markdown_to_streamfield
 from wagapi.formatting.output import (
     format_page_created,
     format_page_deleted,
@@ -27,6 +27,15 @@ def _require_client(ctx: Context):
         )
 
 
+def _is_streamfield(ctx: Context, page_type: str, field_name: str) -> bool:
+    """Check if a field is a StreamField by looking for it in streamfield_blocks."""
+    try:
+        schema = ctx.client.get_page_type_schema(page_type)
+        return field_name in schema.get("streamfield_blocks", {})
+    except Exception:
+        return True  # default to StreamField if schema lookup fails
+
+
 def _parse_parent(value: str) -> int | str:
     """Parse parent as int ID or string path."""
     try:
@@ -175,7 +184,11 @@ def create(ctx: Context, page_type, parent, title, slug, fields, body, publish,
             except json.JSONDecodeError:
                 data["body"] = body
         else:
-            data["body"] = markdown_to_streamfield(body)
+            # Check if body is a StreamField or RichTextField
+            if _is_streamfield(ctx, page_type, "body"):
+                data["body"] = markdown_to_streamfield(body)
+            else:
+                data["body"] = markdown_to_richtext(body)
 
     if publish:
         data["action"] = "publish"
@@ -225,7 +238,13 @@ def update(ctx: Context, page_id, title, slug, fields, body, publish, raw):
             except json.JSONDecodeError:
                 data["body"] = body
         else:
-            data["body"] = markdown_to_streamfield(body)
+            # Fetch page to determine its type, then check schema
+            page_data = ctx.client.get_page(page_id)
+            page_type = page_data.get("meta", {}).get("type", "")
+            if _is_streamfield(ctx, page_type, "body"):
+                data["body"] = markdown_to_streamfield(body)
+            else:
+                data["body"] = markdown_to_richtext(body)
 
     if publish:
         data["action"] = "publish"

{wagapi-0.2.2 → wagapi-0.3.0}/wagapi/formatting/output.py

@@ -65,6 +65,36 @@ def format_page_unpublished(data: dict) -> str:
     return f'✓ Unpublished page {data.get("id", "?")} "{data.get("title", "")}"'
 
 
+def _streamfield_preview(blocks: list[dict], max_len: int = 200) -> str:
+    """Extract a plain-text preview from StreamField blocks."""
+    import re
+
+    parts = []
+    for block in blocks:
+        btype = block.get("type", "")
+        val = block.get("value", "")
+        if btype == "heading":
+            text = val.get("text", "") if isinstance(val, dict) else str(val)
+            parts.append(text)
+        elif btype in ("paragraph", "text"):
+            text = re.sub(r"<[^>]+>", "", str(val))
+            parts.append(text)
+    preview = " / ".join(parts)
+    if len(preview) > max_len:
+        preview = preview[: max_len - 1] + "…"
+    return preview
+
+
+def _richtext_preview(html: str, max_len: int = 200) -> str:
+    """Extract a plain-text preview from HTML rich text."""
+    import re
+
+    text = re.sub(r"<[^>]+>", "", str(html)).strip()
+    if len(text) > max_len:
+        text = text[: max_len - 1] + "…"
+    return text
+
+
 def format_page_detail(data: dict) -> str:
     meta = data.get("meta", {})
     status = "live" if meta.get("live") else "draft"
@@ -73,7 +103,9 @@ def format_page_detail(data: dict) -> str:
         f'  Type: {meta.get("type", "unknown")}',
         f'  Slug: {data.get("slug", "")}',
     ]
-    if meta.get("html_url"):
+    if meta.get("url_path"):
+        lines.append(f'  Path: {meta["url_path"]}')
+    elif meta.get("html_url"):
         lines.append(f'  URL: {meta["html_url"]}')
     if meta.get("parent_id"):
         lines.append(f'  Parent: {meta["parent_id"]}')
@@ -84,13 +116,20 @@ def format_page_detail(data: dict) -> str:
         if key in skip or value is None:
             continue
         if isinstance(value, list) and value and isinstance(value[0], dict) and "type" in value[0]:
-            # StreamField — summarise block types
-            block_types = [b.get("type", "?") for b in value]
-            lines.append(f"  {key}: [{', '.join(block_types)}] ({len(value)} blocks)")
+            # StreamField — show preview
+            preview = _streamfield_preview(value)
+            if preview:
+                lines.append(f"  {key}: {preview}")
+            else:
+                block_types = [b.get("type", "?") for b in value]
+                lines.append(f"  {key}: [{', '.join(block_types)}] ({len(value)} blocks)")
         elif isinstance(value, list) and value:
             lines.append(f"  {key}: {len(value)} items")
         elif isinstance(value, list):
             pass  # skip empty lists
+        elif isinstance(value, str) and value.startswith("<"):
+            # RichTextField HTML — show preview
+            lines.append(f"  {key}: {_richtext_preview(value)}")
         else:
             lines.append(f"  {key}: {value}")
 
@@ -105,9 +144,11 @@ def format_page_list(data: dict) -> str:
     for page in items:
         meta = page.get("meta", {})
         status = "live" if meta.get("live") else "draft"
+        url_path = meta.get("url_path", "")
+        path_col = f"  {url_path}" if url_path else ""
         lines.append(
             f'  {page["id"]:>5}  {page.get("title", "Untitled"):<40}  '
-            f'{meta.get("type", ""):<30}  {status}'
+            f'{meta.get("type", ""):<30}  {status}{path_col}'
         )
     total = data.get("meta", {}).get("total_count", len(items))
     header = f"Pages ({total} total):\n"
@@ -147,6 +188,9 @@ def format_schema_detail(data: dict) -> str:
     properties = create_schema.get("properties", {})
     required_fields = set(create_schema.get("required", []))
 
+    streamfield_fields = set(data.get("streamfield_blocks", {}).keys())
+    richtext_fields = set(data.get("richtext_fields", []))
+
     if properties:
         req_lines = []
         opt_lines = []
@@ -157,6 +201,11 @@ def format_schema_detail(data: dict) -> str:
                 types = [t.get("type", t.get("format", "")) for t in field_schema["anyOf"] if t.get("type") != "null"]
                 ftype = types[0] if types else "unknown"
             ftype = ftype or "unknown"
+            # Use Wagtail-specific type names for clarity
+            if field_name in streamfield_fields:
+                ftype = "StreamField"
+            elif field_name in richtext_fields:
+                ftype = "RichText"
             desc = field_schema.get("description", field_schema.get("title", ""))
             entry = f"    {field_name:<20} {ftype:<15} {desc}"
             if field_name in required_fields:

wagapi-0.2.2/wagapi/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.2"