@diviops/mcp-server 0.2.23 → 0.2.28

package/README.md

@@ -96,9 +96,9 @@ The server connects via standard WordPress REST API and works with any environme
 
 > **WP-CLI note:** `WP_PATH` keeps the existing Local by Flywheel behavior by running `wp` directly on the host filesystem. For Docker-based environments (DDEV, wp-env, DevKinsta, WordPress Studio), set `WP_CLI_CMD` to the wrapper command instead. When `WP_CLI_CMD` is set, the server executes the wrapper from `WP_PATH` if provided, otherwise from its current working directory. The MCP server still validates the requested WP-CLI subcommand against its allowlist before executing either path.
 
-## Available Tools (55)
+## Available Tools (57)
 
-### Read (26)
+### Read (27)
 | Tool | Description |
 |------|-------------|
 | `diviops_test_connection` | Test WordPress connection and Divi version |
@@ -115,7 +115,7 @@ The server connects via standard WordPress REST API and works with any environme
 | `diviops_find_icon` | Search 1,989 icons by keyword (FA + Divi) |
 | `diviops_list_templates` | List available MCP prompt templates |
 | `diviops_get_template` | Get a specific template's block markup |
-| `diviops_preset_audit` | Audit presets with referenced/unreferenced analysis. Walks both page content and in-registry `groupPresets` chains; exposes `block_ref_count`, `group_ref_count`, `referenced_by_presets` |
+| `diviops_preset_audit` | Audit presets with referenced/unreferenced analysis. Walks both page content and in-registry `groupPresets` chains; exposes `block_ref_count`, `group_ref_count`, `referenced_by_presets`. Also reports `orphan_default_pointers` — per-bucket `default` pointers referencing UUIDs missing from `items[]` (legacy damage from past unsafe deletes; clear via `diviops_preset_set_default` in bucket-addressed mode: `type` + `module` + `unset=true`) |
 | `diviops_preset_scan_orphans` | List page-referenced preset UUIDs missing from the D5 registry (separates dangling orphans from D4-legacy refs) |
 | `diviops_list_library` | List saved Divi Library items |
 | `diviops_get_library_item` | Get a library item's block markup |
@@ -125,10 +125,11 @@ The server connects via standard WordPress REST API and works with any environme
 | `diviops_get_tb_layout` | Get a Theme Builder layout's block markup (header/body/footer) |
 | `diviops_list_variables` | List design token variables (filter by type or prefix) |
 | `diviops_variables_scan_orphans` | Find `gvid-`/`gcid-` refs with no backing Variable Manager entry (orphans render as invalid CSS) + unused variables (defined, never referenced). Scans pages, Theme Builder layouts (header/body/footer), Divi Library items, canvas pages, and the preset registry |
+| `diviops_variables_used_on_page` | Detect which `gvid-` (numeric/font) IDs a single page emits — the exact set Divi 5.4.0+ uses to scope selective `:root{--gvid-*}` CSS variable emission. Walks the same content stack the frontend assembles (post_content + active TB header/body/footer + appended canvases + presets). `gcid-` colors are out of scope (separate emission path). Use for per-page orphan validation, preflight before bulk variable rename, or to debug why a numeric/font variable doesn't render on a specific page. Read-only |
 | `diviops_list_canvases` | List all canvas pages |
 | `diviops_get_canvas` | Get canvas content |
 
-### Write (27)
+### Write (28)
 | Tool | Description |
 |------|-------------|
 | `diviops_create_page` | Create a new page with optional Divi content |
@@ -148,12 +149,13 @@ The server connects via standard WordPress REST API and works with any environme
 | `diviops_preset_create` | Write a new preset to the D5 registry (module or group type, supports `divi/column` etc.). Optional `make_default: true` sets it as the bucket's default; optional `priority` controls stack-merge order |
 | `diviops_preset_reassign` | Rewrite `modulePreset` references across pages (dry-run by default; optional `strip_inline` removes redundant inline attrs) |
 | `diviops_preset_update` | Update a specific preset (name, attrs, priority) |
-| `diviops_preset_delete` | Delete a preset by ID |
-| `diviops_preset_set_default` | Set or clear the per-module/group default preset (defaults apply to NEW instances only — use `diviops_preset_reassign` for retroactive swaps) |
+| `diviops_preset_delete` | Delete a preset by ID. Refuses with HTTP 409 `preset_is_default` when the target is the registered default for its bucket — clear the pointer first via `diviops_preset_set_default` with `unset=true`, or pass `force=true` to delete and clear the pointer in one write |
+| `diviops_preset_set_default` | Set or clear the per-module/group default preset. Two modes: by `preset_id` (UUID-addressed; auto-resolves bucket) or by `type` + `module` + `unset=true` (bucket-addressed clear, used to repair orphan default pointers when the UUID is gone from `items[]`). Defaults apply to NEW instances only — use `diviops_preset_reassign` for retroactive swaps |
 | `diviops_save_to_library` | Save block markup to Divi Library |
 | `diviops_update_tb_layout` | Update a Theme Builder layout's block markup |
 | `diviops_create_tb_template` | Create Theme Builder template with header/footer and conditions |
 | `diviops_create_variable` | Create a design token variable. For `type=numbers` fluid tokens, pass `min`+`max` shorthand (anchors default to 320px/1920px) or explicit `targets` like `{"320px":"20px","1920px":"60px"}` — server generates arithmetically-correct `clamp()` instead of hand-written math that silently under-reaches the stated max. All-px inputs emit px (root-agnostic). Rem inputs OR rem output require explicit opt-in: pass `output_unit="rem"` (accepts the 1rem=16px default) or `root_font_size_px:N` (declares your site's actual root font-size, e.g. `10` for `html { font-size: 62.5% }`, `20` for `html { font-size: 20px }`) |
+| `diviops_create_fluid_system` | Batch-emit a fluid typography + spacing + radius variable set in one call. Mirrors Divi 5.4.0's Variable Generator Modal at the algorithm level (clamp() math is identical to `diviops_create_variable`'s fluid mode) but layers profile-selectable anchors over it: `divi-default` (360→1350) matches ET's defaults, `wide` (320→1920) matches the diviops convention, `custom` takes explicit anchors. Each category is independent and optional. Typography uses modular-scale chains (named ratios `major-third`/`perfect-fifth`/`golden`/etc., or raw numbers) — h1 = largest, hN = base. Spacing/radius support `linear` or `geometric` step distributions. `dry_run: true` returns the full plan without persisting; `overwrite: false` (default) skips existing IDs. Single atomic write to the registry — mid-batch failures roll back cleanly |
 | `diviops_delete_variable` | Delete a variable by ID. Returns HTTP 409 when live references exist unless `force=true` (use `diviops_variables_scan_orphans` to find reference locations). Returns HTTP 403 for Divi's customizer-bound defaults (`gcid-primary-color`, `gcid-secondary-color`, `gcid-heading-color`, `gcid-body-color`, `gcid-link-color` — managed via WP Customizer) |
 | `diviops_create_canvas` | Create a canvas page |
 | `diviops_update_canvas` | Update canvas content |
@@ -248,7 +250,7 @@ The three DEFAULT-tier filesystem commands (`wp export`, `acf export <path>`, `a
 
 ## Safety Patterns
 
-High-risk or bulk destructive tools follow one of two conventions to guard against unintended mutation. Both are stateless (no session tokens between calls), but they guard differently: Pattern A is a **stateless gate** — the first call mutates when the safety check passes, refuses with an explanatory error when it fires. Pattern B is **preview-before-commit** — the first call never mutates; an explicit apply step is required. Tools without a gate (e.g., `diviops_preset_delete`, `diviops_update_page_content`) execute their mutation directly — whether to adopt a pattern is a per-tool design decision, not a retrofit requirement.
+High-risk or bulk destructive tools follow one of two conventions to guard against unintended mutation. Both are stateless (no session tokens between calls), but they guard differently: Pattern A is a **stateless gate** — the first call mutates when the safety check passes, refuses with an explanatory error when it fires. Pattern B is **preview-before-commit** — the first call never mutates; an explicit apply step is required. Tools without a gate (e.g., `diviops_update_page_content`) execute their mutation directly — whether to adopt a pattern is a per-tool design decision, not a retrofit requirement.
 
 ### Pattern A — `force: false/true` (refuse-with-override)
 
@@ -264,6 +266,7 @@ Tool refuses the operation with an explanatory error when a safety check fails;
 | Tool | Guard | Override |
 |------|-------|----------|
 | `diviops_delete_variable` | HTTP 409 when live references exist | `force=true` |
+| `diviops_preset_delete` | HTTP 409 `preset_is_default` when target is the registered default for its bucket | `force=true` (deletes + clears the `default` pointer in the same write) |
 
 ### Pattern B — `mode: "dry-run"/"apply"` (preview-then-commit)
 

package/dist/compatibility.d.ts

@@ -2,7 +2,7 @@
  * Version compatibility between MCP server and WP plugin.
  */
 /** Minimum WP plugin version this server requires. */
-export declare const MIN_PLUGIN_VERSION = "1.0.0-beta.38";
+export declare const MIN_PLUGIN_VERSION = "1.0.0-beta.43";
 /**
  * Compare two semver-like version strings (supports pre-release tags).
  *

package/dist/compatibility.js

@@ -2,7 +2,7 @@
  * Version compatibility between MCP server and WP plugin.
  */
 /** Minimum WP plugin version this server requires. */
-export const MIN_PLUGIN_VERSION = '1.0.0-beta.38';
+export const MIN_PLUGIN_VERSION = '1.0.0-beta.43';
 /**
  * Compare two semver-like version strings (supports pre-release tags).
  *

package/dist/index.js

@@ -746,7 +746,7 @@ server.registerTool("diviops_create_page", {
 });
 // ── Preset Tools ────────────────────────────────────────────────────
 server.registerTool("diviops_preset_audit", {
-    description: "Audit all Divi presets (module + group). Each entry reports `block_ref_count` (page-content refs via modulePreset / groupPreset block markup), `group_ref_count` (in-registry chain refs from other presets — module presets via top-level `groupPresets.<slot>.presetId`, group presets via `attrs.groupPreset.<slot>.presetId`), and `referenced` (true if either > 0). Group presets that are chain-referenced also expose `referenced_by_presets` (UUIDs of the presets that wire them in — typically module presets, but type-agnostic). Use this before deleting — orphan-cleanup based only on page refs would silently wipe load-bearing chain-wired group presets (font, border, box-shadow, spacing, button).",
+    description: "Audit all Divi presets (module + group). Each entry reports `block_ref_count` (page-content refs via modulePreset / groupPreset block markup), `group_ref_count` (in-registry chain refs from other presets — module presets via top-level `groupPresets.<slot>.presetId`, group presets via `attrs.groupPreset.<slot>.presetId`), and `referenced` (true if either > 0). Group presets that are chain-referenced also expose `referenced_by_presets` (UUIDs of the presets that wire them in — typically module presets, but type-agnostic). Use this before deleting — orphan-cleanup based only on page refs would silently wipe load-bearing chain-wired group presets (font, border, box-shadow, spacing, button). Also reports `orphan_default_pointers`: per-bucket `default` pointers that reference a UUID no longer present in `items[]` (caused by past unsafe deletes). Render-safe but blocks Divi's lazy recreate-on-VB-use path; clear via diviops_preset_set_default with unset=true on the affected module/group.",
 }, async () => {
     const result = await wp.request("/preset-audit");
     return {
@@ -835,14 +835,21 @@ server.registerTool("diviops_preset_update", {
     };
 });
 server.registerTool("diviops_preset_delete", {
-    description: "Delete a specific preset by ID. Use diviops_preset_audit first to verify the preset is unreferenced before deleting.",
+    description: "Delete a specific preset by ID. Use diviops_preset_audit first to verify the preset is unreferenced before deleting. Refuses with 409 preset_is_default if the target is the registered default for its module/group bucket — clear the pointer first via diviops_preset_set_default with unset=true, or pass force=true to delete and clear the pointer in one write.",
     inputSchema: {
         preset_id: z.string().describe("Preset ID to delete"),
+        force: z
+            .boolean()
+            .optional()
+            .describe("When true, deletes the preset even if it is the registered default and clears the default pointer in the same write. Default false (refuse-by-default)."),
     },
-}, async ({ preset_id }) => {
+}, async ({ preset_id, force }) => {
+    const body = { preset_id };
+    if (force !== undefined)
+        body.force = force;
     const result = await wp.request("/preset-delete", {
         method: "POST",
-        body: { preset_id },
+        body,
     });
     return {
         content: [
@@ -969,18 +976,33 @@ server.registerTool("diviops_preset_scan_orphans", {
     };
 });
 server.registerTool("diviops_preset_set_default", {
-    description: "Set or clear the per-module/group default preset. Walks both buckets to locate the preset by UUID, then points the containing module/group's `default` slot at it. Pass unset=true to clear the slot back to none. Defaults apply to NEW module instances only — existing modules keep their current preset bindings (use diviops_preset_reassign for retroactive swaps). Use diviops_preset_audit's `is_default` field to verify state before/after.",
+    description: "Set or clear the per-module/group default preset. Two addressing modes: (1) preset_id mode — walks both buckets to locate the preset by UUID, then points the containing module/group's `default` slot at it (or clears it with unset=true). (2) Bucket-addressed clear — pass type + module + unset=true to clear an orphan default pointer when the preset_id no longer exists in items[] (the preset_id walk path can't locate orphans — that's the very state being repaired; surfaced via diviops_preset_audit's `orphan_default_pointers`). Defaults apply to NEW module instances only — existing modules keep their current preset bindings (use diviops_preset_reassign for retroactive swaps). Use diviops_preset_audit's `is_default` and `orphan_default_pointers` fields to verify state before/after.",
     inputSchema: {
         preset_id: z
             .string()
-            .describe("Preset UUID. Bucket (module vs. group) and target module/group are auto-resolved from the registry — no need to specify them."),
+            .optional()
+            .describe("Preset UUID. Bucket (module vs. group) and target module/group are auto-resolved from the registry — no need to specify them. Required unless using bucket-addressed clear (type + module + unset=true) to repair an orphan default pointer."),
+        type: z
+            .enum(["module", "group"])
+            .optional()
+            .describe("Bucket-addressed clear: bucket type. Required together with `module` and `unset=true` to clear an orphan default pointer (UUID gone from items[] but `default` still references it)."),
+        module: z
+            .string()
+            .optional()
+            .describe('Bucket-addressed clear: module slug or group key (e.g. "divi/blurb", "divi/font"). Required together with `type` and `unset=true`.'),
         unset: z
             .boolean()
             .optional()
-            .describe("If true, clear the default pointer for the module/group this preset lives in (regardless of whether this preset is currently the default). Defaults to false (set the preset as the default)."),
+            .describe("If true, clear the default pointer. With preset_id, clears the bucket containing that preset. With type+module, clears that bucket directly (use this form for orphan-pointer repair). Defaults to false (set the preset as the default — preset_id required)."),
     },
-}, async ({ preset_id, unset }) => {
-    const body = { preset_id };
+}, async ({ preset_id, type, module, unset }) => {
+    const body = {};
+    if (preset_id !== undefined)
+        body.preset_id = preset_id;
+    if (type !== undefined)
+        body.type = type;
+    if (module !== undefined)
+        body.module = module;
     if (unset)
         body.unset = true;
     const result = await wp.request("/preset-set-default", {
@@ -1590,6 +1612,174 @@ server.registerTool("diviops_create_variable", {
         ],
     };
 });
+server.registerTool("diviops_create_fluid_system", {
+    description: "Batch-emit a fluid typography + spacing + radius variable set in one call — mirrors Divi 5.4.0's Variable Generator Modal at the algorithm level (clamp() math is identical to diviops_create_variable's fluid mode) but layers profile-selectable anchors over it. Each category is independent and optional. Use for: (1) bootstrapping a design system in one call instead of 20+ individual diviops_create_variable invocations; (2) mirroring ET's variable layout so your tokens coexist with VB-generated ones in the Variable Manager; (3) deterministic preflight via dry_run before committing the registry change. By default, refuses to overwrite existing IDs (returns them in `skipped`) — pass overwrite=true to update in place. Persists in a single atomic write to the variable registry; mid-batch failures roll back cleanly.",
+    inputSchema: {
+        profile: z
+            .enum(["divi-default", "wide", "custom"])
+            .optional()
+            .default("divi-default")
+            .describe('Anchor preset for the underlying clamp() math. "divi-default" (360→1350) matches Divi 5.4.0\'s Variable Generator Modal defaults; "wide" (320→1920) covers a wider device span (the diviops convention); "custom" requires custom_anchors. Affects ALL three categories uniformly.'),
+        custom_anchors: z
+            .object({
+            min_viewport_px: z.number().positive(),
+            max_viewport_px: z.number().positive(),
+        })
+            .refine((a) => a.max_viewport_px > a.min_viewport_px, {
+            message: "custom_anchors.max_viewport_px must be > min_viewport_px",
+        })
+            .optional()
+            .describe('Required when profile="custom". Defines the (min_viewport_px, max_viewport_px) pair the clamp() formulas anchor to. max must be > min. (The profile/custom_anchors pairing is also enforced server-side, returning 400 invalid_profile if profile="custom" is sent without custom_anchors.)'),
+        typography: z
+            .object({
+            base_px: z
+                .number()
+                .positive()
+                .describe("Base body size in px. Step N's value = base_px × ratio^(steps-1). h1 = largest (top of chain), hN = base."),
+            ratio: z
+                .union([
+                z.number().positive(),
+                z.enum([
+                    "minor-second",
+                    "major-second",
+                    "minor-third",
+                    "major-third",
+                    "perfect-fourth",
+                    "augmented-fourth",
+                    "perfect-fifth",
+                    "golden",
+                ]),
+            ])
+                .describe("Modular-scale ratio. Pass a named scale ('major-third'=1.25, 'perfect-fifth'=1.5, 'golden'=1.618, etc.) or a raw number. Step N is base × ratio^(steps-N), so h1 (step 1) is the largest size when steps>1."),
+            steps: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .describe("Number of typography steps to emit (e.g. 6 = h1..h6). Cap is 20 to prevent runaway scale chains."),
+            max_ratio: z
+                .union([
+                z.number().positive(),
+                z.enum([
+                    "minor-second",
+                    "major-second",
+                    "minor-third",
+                    "major-third",
+                    "perfect-fourth",
+                    "augmented-fourth",
+                    "perfect-fifth",
+                    "golden",
+                ]),
+            ])
+                .optional()
+                .describe("Optional ratio at max viewport. Defaults to ratio (same chain at both anchors). Pass a larger value (e.g. ratio=1.2 + max_ratio=1.333) for a more dramatic scale on large screens."),
+            fluid_growth: z
+                .number()
+                .positive()
+                .optional()
+                .describe("Multiplicative growth factor at max viewport. Default 1.0 = discrete (each step emits a fixed value, no clamp growth). Common values: 1.2-1.5 for moderate fluid scaling. Step N's clamp goes from `base × ratio^(steps-N)` at min_viewport to `base × max_ratio^(steps-N) × fluid_growth` at max_viewport."),
+            name_prefix: z
+                .string()
+                .optional()
+                .describe("ID prefix per step. Default 'h' → IDs become gvid-{namespace}-size-h1..hN. Pass 'display' for hero sizes ('gvid-{namespace}-size-display1..')."),
+        })
+            .optional(),
+        spacing: z
+            .object({
+            min_px: z.number().min(0),
+            max_px: z.number().positive(),
+            steps: z.number().int().min(1).max(30),
+            scale: z
+                .enum(["linear", "geometric"])
+                .optional()
+                .default("linear")
+                .describe("Distribution between min_px and max_px. 'linear' = equal arithmetic spacing (best for spacing scales). 'geometric' = equal multiplicative spacing (best for typography-like scales). geometric requires min_px > 0."),
+            fluid_growth: z
+                .number()
+                .positive()
+                .optional()
+                .describe("Multiplicative growth factor at max viewport. Default 1.0 = discrete (each spacing token is constant across viewports — typical design-system behavior). > 1.0 = fluid (each token scales from `value` at min_viewport to `value × fluid_growth` at max_viewport)."),
+            name_prefix: z
+                .string()
+                .optional()
+                .describe("ID prefix. Default 'space' → gvid-{namespace}-space-1..N."),
+        })
+            .optional(),
+        radius: z
+            .object({
+            min_px: z.number().min(0),
+            max_px: z.number().positive(),
+            steps: z.number().int().min(1).max(30),
+            scale: z.enum(["linear", "geometric"]).optional().default("linear"),
+            fluid_growth: z
+                .number()
+                .positive()
+                .optional()
+                .describe("Multiplicative growth factor at max viewport. Default 1.0 = discrete. Most radius tokens stay discrete; pass > 1.0 only when you want corners to grow with viewport."),
+            name_prefix: z
+                .string()
+                .optional()
+                .describe("ID prefix. Default 'rounded' → gvid-{namespace}-rounded-1..N."),
+        })
+            .optional(),
+        namespace: z
+            .string()
+            .regex(/^[a-z0-9_-]+$/i, {
+            message: "namespace must match [a-z0-9_-]+ (case-insensitive; lowercased server-side). Inputs outside this charset are rejected explicitly rather than silently rewritten — passing 'o a' or 'oa!' would alias onto the default 'oa' namespace and risk overwriting unrelated tokens.",
+        })
+            .optional()
+            .default("oa")
+            .describe("Namespace inserted into every generated ID (gvid-{namespace}-*). Default 'oa' matches existing diviops convention. Validated against [a-z0-9_-]+ on both client and server (rejects rather than sanitizes — see message for rationale)."),
+        output_unit: z
+            .enum(["rem", "px"])
+            .optional()
+            .describe('Unit for emitted clamp() formulas. Defaults to "px" (root-agnostic, safe). Pass "rem" to opt into rem emission (bakes the 1rem=16px assumption unless root_font_size_px is also passed).'),
+        root_font_size_px: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Site's actual root font-size in px. Pass for non-16px-root sites (e.g. 10 for `html { font-size: 62.5% }`). Passing this alone implies output_unit='rem'."),
+        dry_run: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Preview the full plan without persisting. Returns identical `created`/`skipped` shape so callers can audit IDs and clamp() values before committing."),
+        overwrite: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("When false (default), existing IDs land in `skipped` with the existing value. When true, each existing ID is updated in place (label + value rewritten, order preserved)."),
+    },
+}, async ({ profile, custom_anchors, typography, spacing, radius, namespace, output_unit, root_font_size_px, dry_run, overwrite, }) => {
+    const body = { profile };
+    if (custom_anchors !== undefined)
+        body.custom_anchors = custom_anchors;
+    if (typography !== undefined)
+        body.typography = typography;
+    if (spacing !== undefined)
+        body.spacing = spacing;
+    if (radius !== undefined)
+        body.radius = radius;
+    if (namespace !== undefined)
+        body.namespace = namespace;
+    if (output_unit !== undefined)
+        body.output_unit = output_unit;
+    if (root_font_size_px !== undefined)
+        body.root_font_size_px = root_font_size_px;
+    if (dry_run !== undefined)
+        body.dry_run = dry_run;
+    if (overwrite !== undefined)
+        body.overwrite = overwrite;
+    const result = await wp.request("/variables-create-fluid-system", {
+        method: "POST",
+        body,
+    });
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(result) },
+        ],
+    };
+});
 server.registerTool("diviops_delete_variable", {
     description: "Delete a design token variable by ID. Auto-detects storage from ID prefix (gcid-* = colors, gvid-* = numbers/strings/etc). Returns HTTP 409 when live references exist unless force=true — run diviops_variables_scan_orphans to see where the references live. Returns HTTP 403 for Divi's customizer-bound defaults (gcid-primary-color, gcid-secondary-color, gcid-heading-color, gcid-body-color, gcid-link-color); those are managed via WP Customizer theme options and can't be deleted via this tool.",
     inputSchema: {
@@ -1623,6 +1813,23 @@ server.registerTool("diviops_variables_scan_orphans", {
         ],
     };
 });
+server.registerTool("diviops_variables_used_on_page", {
+    description: "Detect which numeric/font variable IDs a single page actually emits — the exact set Divi 5.4.0+ uses to scope selective `:root{--gvid-*}` CSS variable emission. Walks the same content stack the frontend assembles: post_content + active Theme Builder header/body/footer template content + appended canvas content (interaction targets etc.), plus presets referenced by that content. NOTE: this is `gvid-*` only — color variables (`gcid-*`) are emitted via a separate path (`GlobalData` color block) that is NOT scoped per-page in 5.4.0; this tool returns gvid IDs only. Use for per-page orphan validation (complements global diviops_variables_scan_orphans), preflight before bulk variable rename (know which pages are affected), or to debug why a numeric/font variable doesn't render on a specific page. Read-only. Returns variable_ids (sorted, deduped), count, and the tb_template_ids resolved for that post.",
+    inputSchema: {
+        post_id: z
+            .number()
+            .int()
+            .positive()
+            .describe("WordPress post/page ID. The page does not need to be Divi-built — TB templates and canvases attached to non-Divi posts are still scanned."),
+    },
+}, async ({ post_id }) => {
+    const result = await wp.request(`/variables-used-on-page/${post_id}`);
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(result) },
+        ],
+    };
+});
 server.registerTool("diviops_flush_static_cache", {
     description: "Flush Divi's compiled static CSS cache under wp-content/et-cache/. wp cache flush does NOT touch these files — the frontend can keep serving stale CSS after a preset/variable/module mutation until the cache is cleared. Delegates to Divi's native ET_Core_PageResource::remove_static_resources when available (response backend: \"divi_native\"), which additionally clears Theme Builder CSS scattered across other post dirs, archive/taxonomy/home/notfound CSS, the object cache, module features cache, post features cache, Google Fonts cache, dynamic assets cache, and post meta caches. Falls back to a targeted filesystem walk of numeric-named et-cache subdirs when the Divi class is absent (backend: \"fs_fallback\"). Provide exactly one selector — no site-wide default to prevent accidental full flush. Idempotent: missing cache root returns 200 with empty list.",
     inputSchema: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diviops/mcp-server",
-  "version": "0.2.23",
+  "version": "0.2.28",
   "description": "MCP server exposing Divi 5 Visual Builder as tools for Claude",
   "type": "module",
   "main": "dist/index.js",