@mangerik/wordpress-mcp 0.1.0

package/dist/prompts.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+/**
+ * Reusable prompt templates that turn common WordPress workflows into one-click
+ * actions for the LLM client.
+ */
+export function registerPrompts(server) {
+    server.registerPrompt("summarize_post", {
+        title: "Summarize a post",
+        description: "Generate a concise summary of a WordPress post.",
+        argsSchema: {
+            post_id: z.string().describe("Post ID to summarize"),
+            length: z.enum(["short", "medium", "long"]).optional(),
+        },
+    }, ({ post_id, length = "medium" }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Read the post at resource wp://post/${post_id} and write a ${length} summary. ` +
+                        `Cover: main thesis, key points, target audience. Use plain prose.`,
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("seo_rewrite", {
+        title: "SEO rewrite",
+        description: "Rewrite a post for SEO without changing the substance.",
+        argsSchema: {
+            post_id: z.string(),
+            primary_keyword: z.string(),
+            target_audience: z.string().optional(),
+        },
+    }, ({ post_id, primary_keyword, target_audience }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Rewrite the post at resource wp://post/${post_id} for SEO.\n` +
+                        `Primary keyword: "${primary_keyword}".\n` +
+                        (target_audience ? `Target audience: ${target_audience}.\n` : "") +
+                        `Constraints:\n` +
+                        `- Preserve facts and intent.\n` +
+                        `- Use the keyword in title, first paragraph, and one H2.\n` +
+                        `- Add a meta description ≤ 155 chars.\n` +
+                        `- Output JSON: { title, content (HTML), excerpt, meta_description, suggested_slug }.\n` +
+                        `Then call wp_update_post to apply the changes (status stays the same).`,
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("translate_page", {
+        title: "Translate a page",
+        description: "Translate a page into another language while preserving HTML structure.",
+        argsSchema: {
+            page_id: z.string(),
+            target_language: z.string().describe("e.g. 'Indonesian', 'fr-FR'"),
+            create_new: z
+                .enum(["true", "false"])
+                .optional()
+                .describe("If 'true', create a new page instead of updating in place."),
+        },
+    }, ({ page_id, target_language, create_new }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Translate the page at resource wp://page/${page_id} into ${target_language}. ` +
+                        `Preserve all HTML tags, attributes, and shortcodes. Translate alt text and titles. ` +
+                        (create_new === "true"
+                            ? `Then call wp_create_page (status=draft) with the translated content.`
+                            : `Then call wp_update_page on the same id with the translated content.`),
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("draft_post", {
+        title: "Draft a new post",
+        description: "Outline and draft a new blog post in WordPress (status=draft).",
+        argsSchema: {
+            topic: z.string(),
+            tone: z.string().optional(),
+            word_count: z.string().optional(),
+        },
+    }, ({ topic, tone = "informative", word_count = "800" }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Draft a WordPress post about: ${topic}.\n` +
+                        `Tone: ${tone}. Target length: ~${word_count} words.\n` +
+                        `Steps:\n` +
+                        `1. Use wp_get_categories and wp_get_tags to find relevant taxonomies.\n` +
+                        `2. Produce title, excerpt, slug, body (HTML with H2/H3 + paragraphs).\n` +
+                        `3. Call wp_create_post with status=draft. Return the new post id.`,
+                },
+            },
+        ],
+    }));
+}
+//# sourceMappingURL=prompts.js.map

package/dist/resources.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WordPressClient } from "./wordpress-client.js";
+/**
+ * Register MCP resources so clients can attach WordPress content as context
+ * without burning a tool call. URIs:
+ *
+ *   wp://site                  → REST root summary
+ *   wp://post/{id}             → single post (rendered HTML + meta)
+ *   wp://page/{id}             → single page
+ *   wp://media/{id}            → media metadata + source_url
+ */
+export declare function registerResources(server: McpServer, wp: WordPressClient): void;
+//# sourceMappingURL=resources.d.ts.map

package/dist/resources.js

@@ -0,0 +1,64 @@
+import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register MCP resources so clients can attach WordPress content as context
+ * without burning a tool call. URIs:
+ *
+ *   wp://site                  → REST root summary
+ *   wp://post/{id}             → single post (rendered HTML + meta)
+ *   wp://page/{id}             → single page
+ *   wp://media/{id}            → media metadata + source_url
+ */
+export function registerResources(server, wp) {
+    server.registerResource("site", "wp://site", {
+        title: "WordPress site info",
+        description: "Site name, description, and discovered REST namespaces.",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const data = await wp.siteInfo();
+        return {
+            contents: [
+                { uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    server.registerResource("post", new ResourceTemplate("wp://post/{id}", { list: undefined }), {
+        title: "WordPress post",
+        description: "Single post by ID with rendered content.",
+        mimeType: "application/json",
+    }, async (uri, vars) => {
+        const id = Number(vars.id);
+        const data = await wp.posts.get(id, { context: "view", _embed: true });
+        return {
+            contents: [
+                { uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    server.registerResource("page", new ResourceTemplate("wp://page/{id}", { list: undefined }), {
+        title: "WordPress page",
+        description: "Single page by ID with rendered content.",
+        mimeType: "application/json",
+    }, async (uri, vars) => {
+        const id = Number(vars.id);
+        const data = await wp.pages.get(id, { context: "view", _embed: true });
+        return {
+            contents: [
+                { uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+    server.registerResource("media", new ResourceTemplate("wp://media/{id}", { list: undefined }), {
+        title: "WordPress media item",
+        description: "Single media item metadata, including source URL.",
+        mimeType: "application/json",
+    }, async (uri, vars) => {
+        const id = Number(vars.id);
+        const data = await wp.media.get(id);
+        return {
+            contents: [
+                { uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=resources.js.map

package/dist/tools/batch.d.ts

@@ -0,0 +1,14 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+/**
+ * Tools for the WP 5.6+ batch endpoint (/batch/v1).
+ *
+ * Notes:
+ *  - GET requests are NOT supported by core; only POST/PUT/PATCH/DELETE.
+ *  - Default max 25 requests per batch (filterable server-side).
+ *  - Response is HTTP 207 with parallel `responses` array, same order as input.
+ *  - The route being batched must declare `'allow_batch' => array('v1' => true)`.
+ *    Most built-in routes do; some plugins do not yet.
+ */
+export declare const batchTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=batch.d.ts.map

package/dist/tools/batch.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+/**
+ * Tools for the WP 5.6+ batch endpoint (/batch/v1).
+ *
+ * Notes:
+ *  - GET requests are NOT supported by core; only POST/PUT/PATCH/DELETE.
+ *  - Default max 25 requests per batch (filterable server-side).
+ *  - Response is HTTP 207 with parallel `responses` array, same order as input.
+ *  - The route being batched must declare `'allow_batch' => array('v1' => true)`.
+ *    Most built-in routes do; some plugins do not yet.
+ */
+export const batchTools = (wp) => [
+    {
+        name: "wp_batch_options",
+        title: "Batch: discover capabilities",
+        description: "OPTIONS /batch/v1 — returns the maximum requests per batch and accepted methods.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async () => wp.batchOptions(),
+    },
+    {
+        name: "wp_batch",
+        title: "Batch: execute write operations in one round-trip",
+        description: "POST /batch/v1 — execute multiple write operations in a single request. " +
+            "GET is not supported. Use validation='require-all-validate' to abort the whole batch if any request is invalid.",
+        inputSchema: {
+            validation: z.enum(["normal", "require-all-validate"]).optional(),
+            requests: z
+                .array(z.object({
+                method: z.enum(["POST", "PUT", "PATCH", "DELETE"]).optional(),
+                path: z
+                    .string()
+                    .min(1)
+                    .describe("Route path beginning with /, e.g. '/wp/v2/posts' or '/wp/v2/posts/123'"),
+                headers: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
+                body: z.record(z.string(), z.unknown()).optional(),
+            }))
+                .min(1)
+                .max(100)
+                .describe("Up to ~25 by default; some sites raise the cap. Check wp_batch_options."),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { requests, validation = "normal" } = input;
+            return wp.batch(requests, validation);
+        },
+    },
+];
+//# sourceMappingURL=batch.js.map

package/dist/tools/blocks.d.ts

@@ -0,0 +1,4 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+export declare const blockTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=blocks.d.ts.map

package/dist/tools/blocks.js

@@ -0,0 +1,202 @@
+import { z } from "zod";
+/**
+ * Tools for WordPress block themes (WP 5.9+):
+ *   - wp_template (full templates)
+ *   - wp_template_part (header / footer / etc.)
+ *   - block-patterns / block-pattern-categories
+ *   - block-types
+ *   - global-styles
+ *   - menus / menu-items / menu-locations (WP 6.6+ menus REST in core; many sites
+ *     also have Gutenberg's nav blocks via wp/v2/navigation)
+ *
+ * Templates use string IDs of the form `theme//slug`, e.g. `twentytwentyfour//single`.
+ */
+const orderEnum = z.enum(["asc", "desc"]);
+export const blockTools = (wp) => [
+    // ── Templates (full block templates) ───────────────────────────────────
+    {
+        name: "wp_list_templates",
+        title: "Block themes: list templates",
+        description: "List block theme templates (wp_template). IDs look like 'theme//slug'.",
+        inputSchema: {
+            theme: z.string().optional().describe("Filter by theme slug"),
+            area: z.string().optional().describe("Filter by template area (e.g. 'header')"),
+            post_type: z.string().optional().describe("Filter by post type the template applies to"),
+            _fields: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const r = await wp.list("wp/v2/templates", input);
+            return { templates: r.data, total: r.total };
+        },
+    },
+    {
+        name: "wp_get_template",
+        title: "Block themes: get template",
+        description: "Get a single template by 'theme//slug' ID.",
+        inputSchema: { id: z.string().min(1) },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id } = input;
+            return wp.raw({
+                method: "GET",
+                path: `/wp/v2/templates/${encodeURIComponent(id)}`,
+            });
+        },
+    },
+    {
+        name: "wp_update_template",
+        title: "Block themes: update template",
+        description: "Update a block template by 'theme//slug' ID. Pass content (block markup) " +
+            "and/or title/description.",
+        inputSchema: {
+            id: z.string().min(1),
+            content: z.string().optional(),
+            title: z.string().optional(),
+            description: z.string().optional(),
+            status: z.enum(["publish", "draft", "auto-draft", "trash"]).optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...body } = input;
+            return wp.raw({
+                method: "POST",
+                path: `/wp/v2/templates/${encodeURIComponent(id)}`,
+                body,
+            });
+        },
+    },
+    // ── Template parts ─────────────────────────────────────────────────────
+    {
+        name: "wp_list_template_parts",
+        title: "Block themes: list template parts",
+        description: "List template parts (wp_template_part), e.g. header / footer fragments.",
+        inputSchema: {
+            theme: z.string().optional(),
+            area: z.string().optional(),
+            _fields: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const r = await wp.list("wp/v2/template-parts", input);
+            return { template_parts: r.data, total: r.total };
+        },
+    },
+    {
+        name: "wp_get_template_part",
+        title: "Block themes: get template part",
+        description: "Get a single template part by 'theme//slug' ID.",
+        inputSchema: { id: z.string().min(1) },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id } = input;
+            return wp.raw({
+                method: "GET",
+                path: `/wp/v2/template-parts/${encodeURIComponent(id)}`,
+            });
+        },
+    },
+    {
+        name: "wp_update_template_part",
+        title: "Block themes: update template part",
+        description: "Update a template part by 'theme//slug' ID.",
+        inputSchema: {
+            id: z.string().min(1),
+            content: z.string().optional(),
+            title: z.string().optional(),
+            description: z.string().optional(),
+            area: z.string().optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...body } = input;
+            return wp.raw({
+                method: "POST",
+                path: `/wp/v2/template-parts/${encodeURIComponent(id)}`,
+                body,
+            });
+        },
+    },
+    // ── Block patterns ─────────────────────────────────────────────────────
+    {
+        name: "wp_list_block_patterns",
+        title: "Block themes: list patterns",
+        description: "List block patterns (registered via PHP, theme.json, or pattern directory).",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async () => {
+            const r = await wp.list("wp/v2/block-patterns/patterns");
+            return { patterns: r.data, total: r.total };
+        },
+    },
+    {
+        name: "wp_list_block_pattern_categories",
+        title: "Block themes: list pattern categories",
+        description: "List the categories used to group block patterns.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async () => {
+            const r = await wp.list("wp/v2/block-patterns/categories");
+            return { categories: r.data, total: r.total };
+        },
+    },
+    // ── Block types ────────────────────────────────────────────────────────
+    {
+        name: "wp_list_block_types",
+        title: "Block themes: list block types",
+        description: "List registered Gutenberg block types.",
+        inputSchema: {
+            namespace: z.string().optional().describe("Filter by block namespace, e.g. 'core'"),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const r = await wp.list("wp/v2/block-types", input);
+            return { block_types: r.data, total: r.total };
+        },
+    },
+    // ── Global styles ──────────────────────────────────────────────────────
+    {
+        name: "wp_get_global_styles",
+        title: "Block themes: get global styles for a theme",
+        description: "Get the active global styles record (theme.json overrides) for a given stylesheet.",
+        inputSchema: {
+            stylesheet: z.string().describe("Theme stylesheet slug, e.g. 'twentytwentyfour'"),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { stylesheet } = input;
+            return wp.raw({
+                method: "GET",
+                path: `/wp/v2/global-styles/themes/${encodeURIComponent(stylesheet)}`,
+            });
+        },
+    },
+    // ── Menus (WP 5.9+ classic menus REST) ─────────────────────────────────
+    {
+        name: "wp_list_menus",
+        title: "Menus: list",
+        description: "List navigation menus.",
+        inputSchema: { _fields: z.string().optional() },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const r = await wp.list("wp/v2/menus", input);
+            return { menus: r.data, total: r.total };
+        },
+    },
+    {
+        name: "wp_list_menu_items",
+        title: "Menus: list items",
+        description: "List items inside menus, optionally filtered by menu ID.",
+        inputSchema: {
+            menus: z.array(z.number().int()).optional(),
+            per_page: z.number().int().min(1).max(100).optional(),
+            _fields: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const r = await wp.list("wp/v2/menu-items", input);
+            return { menu_items: r.data, total: r.total };
+        },
+    },
+];
+//# sourceMappingURL=blocks.js.map

package/dist/tools/comments.d.ts

@@ -0,0 +1,4 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+export declare const commentTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=comments.d.ts.map

package/dist/tools/comments.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+export const commentTools = (wp) => [
+    {
+        name: "wp_get_comments",
+        title: "List comments",
+        description: "List WordPress comments with filters.",
+        inputSchema: {
+            page: z.number().int().positive().optional(),
+            per_page: z.number().int().min(1).max(100).optional(),
+            search: z.string().optional(),
+            post: z.number().int().optional(),
+            status: z.enum(["approved", "hold", "spam", "trash", "any"]).optional(),
+            author_email: z.string().email().optional(),
+            after: z.string().optional(),
+            before: z.string().optional(),
+            orderby: z.enum(["date", "id", "post"]).optional(),
+            order: z.enum(["asc", "desc"]).optional(),
+            _fields: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const result = await wp.comments.list(input);
+            return { comments: result.data, total: result.total };
+        },
+    },
+    {
+        name: "wp_get_comment",
+        title: "Get a comment",
+        description: "Get a single comment by ID.",
+        inputSchema: { id: z.number().int().positive() },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => wp.comments.get(input.id),
+    },
+    {
+        name: "wp_create_comment",
+        title: "Create a comment",
+        description: "Create a comment on a post.",
+        inputSchema: {
+            post: z.number().int().positive(),
+            content: z.string().min(1),
+            author_name: z.string().optional(),
+            author_email: z.string().email().optional(),
+            parent: z.number().int().optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => wp.comments.create(input),
+    },
+    {
+        name: "wp_update_comment",
+        title: "Update / moderate a comment",
+        description: "Update or moderate a comment. Use status to approve / hold / spam / trash.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            content: z.string().optional(),
+            status: z.enum(["approved", "hold", "spam", "trash"]).optional(),
+            author_name: z.string().optional(),
+            author_email: z.string().email().optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...data } = input;
+            return wp.comments.update(id, data);
+        },
+    },
+    {
+        name: "wp_delete_comment",
+        title: "Delete a comment",
+        description: "Move a comment to trash, or permanently delete with force=true.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            force: z.boolean().optional(),
+        },
+        annotations: { destructiveHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id, force = false } = input;
+            return wp.comments.remove(id, force);
+        },
+    },
+];
+//# sourceMappingURL=comments.js.map

package/dist/tools/cpt.d.ts

@@ -0,0 +1,16 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+/**
+ * Generic tools for working with custom post types and custom taxonomies.
+ *
+ * `route` examples:
+ *   - "wp/v2/product"           (a CPT named `product` registered with show_in_rest)
+ *   - "wp/v2/product_cat"       (a custom taxonomy)
+ *   - "wc/v3/products"          (WooCommerce — different namespace)
+ *   - "yoast/v1/get_head"       (Yoast)
+ *
+ * Use `wp_get_post_types` / `wp_get_taxonomies` / `wp_site_info` first to discover
+ * what's available on the target site.
+ */
+export declare const cptTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=cpt.d.ts.map

package/dist/tools/cpt.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+/**
+ * Generic tools for working with custom post types and custom taxonomies.
+ *
+ * `route` examples:
+ *   - "wp/v2/product"           (a CPT named `product` registered with show_in_rest)
+ *   - "wp/v2/product_cat"       (a custom taxonomy)
+ *   - "wc/v3/products"          (WooCommerce — different namespace)
+ *   - "yoast/v1/get_head"       (Yoast)
+ *
+ * Use `wp_get_post_types` / `wp_get_taxonomies` / `wp_site_info` first to discover
+ * what's available on the target site.
+ */
+export const cptTools = (wp) => [
+    {
+        name: "wp_list_items",
+        title: "Generic list (any REST route)",
+        description: "List items from any REST collection route (CPT, custom taxonomy, plugin namespace). " +
+            "Pass plugin/CPT-specific params via `query`.",
+        inputSchema: {
+            route: z
+                .string()
+                .min(1)
+                .describe("REST route, e.g. 'wp/v2/product' or 'wc/v3/products'"),
+            query: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe("Query string parameters as key/value pairs"),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { route, query } = input;
+            const result = await wp.list(route, query);
+            return { items: result.data, total: result.total, total_pages: result.pages };
+        },
+    },
+    {
+        name: "wp_get_item",
+        title: "Generic get (any REST route)",
+        description: "Get a single item from any REST route by ID.",
+        inputSchema: {
+            route: z.string().min(1),
+            id: z.number().int().positive(),
+            query: z.record(z.string(), z.unknown()).optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { route, id, query } = input;
+            return wp.get(route, id, query);
+        },
+    },
+    {
+        name: "wp_create_item",
+        title: "Generic create (any REST route)",
+        description: "Create an item on any REST route. Use `wp_get_post_types` to find supported CPT slugs.",
+        inputSchema: {
+            route: z.string().min(1),
+            body: z.record(z.string(), z.unknown()),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { route, body } = input;
+            return wp.create(route, body);
+        },
+    },
+    {
+        name: "wp_update_item",
+        title: "Generic update (any REST route)",
+        description: "Update an item on any REST route by ID.",
+        inputSchema: {
+            route: z.string().min(1),
+            id: z.number().int().positive(),
+            body: z.record(z.string(), z.unknown()),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { route, id, body } = input;
+            return wp.update(route, id, body);
+        },
+    },
+    {
+        name: "wp_delete_item",
+        title: "Generic delete (any REST route)",
+        description: "Delete an item on any REST route. Many endpoints require force=true.",
+        inputSchema: {
+            route: z.string().min(1),
+            id: z.number().int().positive(),
+            force: z.boolean().optional(),
+        },
+        annotations: { destructiveHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { route, id, force = false } = input;
+            return wp.remove(route, id, force);
+        },
+    },
+];
+//# sourceMappingURL=cpt.js.map

package/dist/tools/jwt.d.ts

@@ -0,0 +1,9 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+/**
+ * JWT auth helper tools (only useful when WP_AUTH_MODE=jwt).
+ * Most users won't need to call these directly — the server fetches a token
+ * automatically at startup. They're handy for diagnostics.
+ */
+export declare const jwtTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=jwt.d.ts.map