@adsim/wordpress-mcp-server 4.6.0 → 5.1.0

package/src/tools/schema.js

@@ -0,0 +1,417 @@
+// src/tools/schema.js — schema tools (7)
+// Definitions + handlers (v5.0.0 refactor Step B+C)
+
+import { json, strip } from '../shared/utils.js';
+import { validateInput } from '../shared/governance.js';
+import { rt } from '../shared/context.js';
+
+export const definitions = [
+  { name: 'wp_generate_schema_article', _category: 'schema', description: 'Use to generate JSON-LD Article schema for a post. Fetches post via REST with _embed and builds complete Article markup with headline, author, dates, image, publisher. Read-only.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post ID' } }, required: ['post_id'] }},
+  { name: 'wp_generate_schema_faq', _category: 'schema', description: 'Use to generate JSON-LD FAQPage schema from post content. Detects Q&A from Gutenberg FAQ blocks, RankMath FAQ, AIOSEO FAQ, <details><summary>, or H3+paragraph patterns. Read-only.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post ID' } }, required: ['post_id'] }},
+  { name: 'wp_generate_schema_howto', _category: 'schema', description: 'Use to generate JSON-LD HowTo schema from post content. Detects steps from ordered lists, numbered H3/H4 headings. Extracts totalTime and estimatedCost if mentioned. Read-only.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post ID' } }, required: ['post_id'] }},
+  { name: 'wp_generate_schema_localbusiness', _category: 'schema', description: 'Use to generate JSON-LD LocalBusiness schema. Pulls data from ACF fields, Yoast Local SEO, or generic WP options. Read-only.',
+        inputSchema: { type: 'object', properties: { target: { type: 'string', description: '"site" (default) or a post ID to use post-level ACF fields' } }}},
+  { name: 'wp_generate_schema_breadcrumb', _category: 'schema', description: 'Use to generate JSON-LD BreadcrumbList schema for a post or page. Rebuilds full hierarchy: Home > Category/Parent > Post. Read-only.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post ID' } }, required: ['post_id'] }},
+  { name: 'wp_inject_schema', _category: 'schema', description: 'Use to inject generated JSON-LD schema into a post _custom_schema_jsonld meta field. The companion mu-plugin outputs it in wp_head. Write — blocked by WP_READ_ONLY (except dry_run=true).',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post ID' }, schema_type: { type: 'string', enum: ['article', 'faq', 'howto', 'localbusiness', 'breadcrumb'], description: 'Schema type to generate and inject' }, override: { type: 'boolean', description: 'If false (default) and meta exists, returns error with existing content' }, dry_run: { type: 'boolean', description: 'If true, generates schema without injecting. Bypasses WP_READ_ONLY.' } }, required: ['post_id', 'schema_type'] }},
+  { name: 'wp_validate_schema_live', _category: 'schema', description: 'Use to validate JSON-LD schema on a live URL. Extracts all <script type="application/ld+json"> blocks, validates structure, checks required fields per type, detects common errors. Read-only.',
+        inputSchema: { type: 'object', properties: { url: { type: 'string', description: 'Public URL to validate' } }, required: ['url'] }}
+];
+
+export const handlers = {};
+
+handlers['wp_generate_schema_article'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 } });
+  const artPost = await wpApiCall(`/posts/${args.post_id}?_embed=true`);
+  const artTitle = artPost.title?.rendered || artPost.title?.raw || '';
+  const artExcerpt = strip(artPost.excerpt?.rendered || '');
+  const artAuthor = artPost._embedded?.author?.[0];
+  const artImage = artPost._embedded?.['wp:featuredmedia']?.[0];
+  let artPublisher = { '@type': 'Organization' };
+  try {
+    const siteOpts = await wpApiCall('/settings', { basePath: '/wp-json/wp/v2' });
+    artPublisher.name = siteOpts.title || siteOpts.name || '';
+    if (siteOpts.site_icon_url) artPublisher.logo = { '@type': 'ImageObject', url: siteOpts.site_icon_url };
+  } catch (_e) {
+    try { const siteInfo = await wpApiCall('/', { basePath: '/wp-json' }); artPublisher.name = siteInfo.name || ''; } catch (_e2) { /* ignore */ }
+  }
+  const artMissing = [];
+  if (!artTitle) artMissing.push('headline');
+  if (!artExcerpt) artMissing.push('description');
+  if (!artAuthor?.name) artMissing.push('author');
+  if (!artImage?.source_url) artMissing.push('image');
+  if (!artPublisher.name) artMissing.push('publisher');
+  const artSchema = {
+    '@context': 'https://schema.org', '@type': 'Article',
+    headline: artTitle,
+    description: artExcerpt || undefined,
+    datePublished: artPost.date || undefined,
+    dateModified: artPost.modified || undefined,
+    url: artPost.link || undefined,
+    author: artAuthor?.name ? { '@type': 'Person', name: artAuthor.name, url: artAuthor.link || undefined } : undefined,
+    image: artImage?.source_url ? { '@type': 'ImageObject', url: artImage.source_url, width: artImage.media_details?.width, height: artImage.media_details?.height } : undefined,
+    publisher: artPublisher.name ? artPublisher : undefined,
+  };
+  // Remove undefined fields
+  Object.keys(artSchema).forEach(k => artSchema[k] === undefined && delete artSchema[k]);
+  result = json({ jsonld: artSchema, fields_present: Object.keys(artSchema).filter(k => k !== '@context' && k !== '@type'), fields_missing: artMissing });
+  auditLog({ tool: name, action: 'generate_schema_article', status: 'success', latency_ms: Date.now() - t0, params: { post_id: args.post_id } });
+  return result;
+};
+handlers['wp_generate_schema_faq'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 } });
+  const faqPost = await wpApiCall(`/posts/${args.post_id}`);
+  const faqHtml = faqPost.content?.rendered || '';
+  const faqPairs = [];
+  let faqMethod = 'none';
+  // 1. Gutenberg FAQ blocks — detect container then extract Q&A pairs
+  if (/wp-block-faq/i.test(faqHtml)) {
+    const gqRe = /<[^>]*class="[^"]*faq-question[^"]*"[^>]*>([\s\S]*?)<\/[^>]+>/gi;
+    const gaRe = /<[^>]*class="[^"]*faq-answer[^"]*"[^>]*>([\s\S]*?)<\/[^>]+>/gi;
+    const gQuestions = [...faqHtml.matchAll(gqRe)].map(m => strip(m[1]));
+    const gAnswers = [...faqHtml.matchAll(gaRe)].map(m => strip(m[1]));
+    for (let i = 0; i < Math.min(gQuestions.length, gAnswers.length); i++) {
+      faqPairs.push({ question: gQuestions[i], answer: gAnswers[i] });
+    }
+  }
+  if (faqPairs.length > 0) faqMethod = 'gutenberg_faq_block';
+  // 2. RankMath FAQ — detect container then extract Q&A pairs
+  if (faqPairs.length === 0 && /rank-math-faq-block/i.test(faqHtml)) {
+    const rmqRe = /<[^>]*class="[^"]*faq-question[^"]*"[^>]*>([\s\S]*?)<\/[^>]+>/gi;
+    const rmaRe = /<[^>]*class="[^"]*faq-answer[^"]*"[^>]*>([\s\S]*?)<\/[^>]+>/gi;
+    const rmQuestions = [...faqHtml.matchAll(rmqRe)].map(m => strip(m[1]));
+    const rmAnswers = [...faqHtml.matchAll(rmaRe)].map(m => strip(m[1]));
+    for (let i = 0; i < Math.min(rmQuestions.length, rmAnswers.length); i++) {
+      faqPairs.push({ question: rmQuestions[i], answer: rmAnswers[i] });
+    }
+    if (faqPairs.length > 0) faqMethod = 'rankmath_faq';
+  }
+  // 3. AIOSEO FAQ — detect container then extract Q&A pairs
+  if (faqPairs.length === 0 && /aioseo-faq/i.test(faqHtml)) {
+    const aioqRe = /<[^>]*class="[^"]*faq-question[^"]*"[^>]*>([\s\S]*?)<\/[^>]+>/gi;
+    const aioaRe = /<[^>]*class="[^"]*faq-answer[^"]*"[^>]*>([\s\S]*?)<\/[^>]+>/gi;
+    const aioQuestions = [...faqHtml.matchAll(aioqRe)].map(m => strip(m[1]));
+    const aioAnswers = [...faqHtml.matchAll(aioaRe)].map(m => strip(m[1]));
+    for (let i = 0; i < Math.min(aioQuestions.length, aioAnswers.length); i++) {
+      faqPairs.push({ question: aioQuestions[i], answer: aioAnswers[i] });
+    }
+    if (faqPairs.length > 0) faqMethod = 'aioseo_faq';
+  }
+  // 4. <details><summary> pattern
+  if (faqPairs.length === 0) {
+    const detRe = /<details[^>]*>\s*<summary[^>]*>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gi;
+    let detM;
+    while ((detM = detRe.exec(faqHtml)) !== null) {
+      faqPairs.push({ question: strip(detM[1]), answer: strip(detM[2]) });
+    }
+    if (faqPairs.length > 0) faqMethod = 'details_summary';
+  }
+  // 5. H3 + next paragraph fallback
+  if (faqPairs.length === 0) {
+    const h3Re = /<h3[^>]*>([\s\S]*?)<\/h3>\s*<p[^>]*>([\s\S]*?)<\/p>/gi;
+    let h3M;
+    while ((h3M = h3Re.exec(faqHtml)) !== null) {
+      faqPairs.push({ question: strip(h3M[1]), answer: strip(h3M[2]) });
+    }
+    if (faqPairs.length > 0) faqMethod = 'h3_paragraph';
+  }
+  const faqSchema = {
+    '@context': 'https://schema.org', '@type': 'FAQPage',
+    mainEntity: faqPairs.map(p => ({ '@type': 'Question', name: p.question, acceptedAnswer: { '@type': 'Answer', text: p.answer } }))
+  };
+  result = json({ jsonld: faqSchema, qa_count: faqPairs.length, detection_method: faqMethod });
+  auditLog({ tool: name, action: 'generate_schema_faq', status: 'success', latency_ms: Date.now() - t0, params: { post_id: args.post_id } });
+  return result;
+};
+handlers['wp_generate_schema_howto'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 } });
+  const htPost = await wpApiCall(`/posts/${args.post_id}`);
+  const htHtml = htPost.content?.rendered || '';
+  const htSteps = [];
+  let htMethod = 'none';
+  // 1. Ordered lists (ol > li)
+  const olRe = /<ol[^>]*class="[^"]*wp-block-list[^"]*"[^>]*>([\s\S]*?)<\/ol>/gi;
+  let olM;
+  while ((olM = olRe.exec(htHtml)) !== null) {
+    const liRe = /<li[^>]*>([\s\S]*?)<\/li>/gi;
+    let liM;
+    while ((liM = liRe.exec(olM[1])) !== null) {
+      const text = strip(liM[1]);
+      if (text) htSteps.push({ name: text.substring(0, 100), text });
+    }
+  }
+  if (htSteps.length > 0) htMethod = 'ordered_list_gutenberg';
+  // 2. Any <ol> fallback
+  if (htSteps.length === 0) {
+    const olAllRe = /<ol[^>]*>([\s\S]*?)<\/ol>/gi;
+    let olAllM;
+    while ((olAllM = olAllRe.exec(htHtml)) !== null) {
+      const liRe2 = /<li[^>]*>([\s\S]*?)<\/li>/gi;
+      let liM2;
+      while ((liM2 = liRe2.exec(olAllM[1])) !== null) {
+        const text = strip(liM2[1]);
+        if (text) htSteps.push({ name: text.substring(0, 100), text });
+      }
+    }
+    if (htSteps.length > 0) htMethod = 'ordered_list';
+  }
+  // 3. Numbered H3/H4 headings
+  if (htSteps.length === 0) {
+    const hRe = /<h[34][^>]*>([\s\S]*?)<\/h[34]>\s*(?:<p[^>]*>([\s\S]*?)<\/p>)?/gi;
+    let hM;
+    while ((hM = hRe.exec(htHtml)) !== null) {
+      const heading = strip(hM[1]);
+      if (/^(?:(?:[ÉéEe]tape|Step)\s*\d+|^\d+[\.\)]\s*)/i.test(heading)) {
+        htSteps.push({ name: heading, text: strip(hM[2] || '') || heading });
+      }
+    }
+    if (htSteps.length > 0) htMethod = 'numbered_headings';
+  }
+  // Extract totalTime (ISO 8601 duration)
+  const timeRe = /PT(?:\d+H)?(?:\d+M)?(?:\d+S)?/i;
+  const timeMatch = htHtml.match(timeRe);
+  const htSchema = {
+    '@context': 'https://schema.org', '@type': 'HowTo',
+    name: strip(htPost.title?.rendered || ''),
+    step: htSteps.map((s, i) => ({ '@type': 'HowToStep', position: i + 1, name: s.name, text: s.text })),
+  };
+  if (timeMatch) htSchema.totalTime = timeMatch[0];
+  // Extract estimatedCost
+  const costRe = /(?:cost|price|budget)[:\s]*[$€£]?\s*([\d,.]+)/i;
+  const costMatch = htHtml.match(costRe);
+  if (costMatch) htSchema.estimatedCost = { '@type': 'MonetaryAmount', value: costMatch[1] };
+  result = json({ jsonld: htSchema, step_count: htSteps.length, detection_method: htMethod, has_total_time: !!timeMatch, has_estimated_cost: !!costMatch });
+  auditLog({ tool: name, action: 'generate_schema_howto', status: 'success', latency_ms: Date.now() - t0, params: { post_id: args.post_id } });
+  return result;
+};
+handlers['wp_generate_schema_localbusiness'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  const lbTarget = args.target || 'site';
+  const lbSources = [];
+  const lbMissing = [];
+  const lbData = {};
+  // Try ACF fields first (site-level or post-level)
+  try {
+    if (lbTarget !== 'site' && !isNaN(parseInt(lbTarget))) {
+      const lbPost = await wpApiCall(`/posts/${parseInt(lbTarget)}`);
+      const acf = lbPost.acf || lbPost.meta || {};
+      if (acf.business_name) { lbData.name = acf.business_name; lbSources.push('acf'); }
+      if (acf.address) { lbData.address = acf.address; lbSources.push('acf'); }
+      if (acf.phone) { lbData.telephone = acf.phone; lbSources.push('acf'); }
+      if (acf.email) { lbData.email = acf.email; lbSources.push('acf'); }
+      if (acf.opening_hours) { lbData.openingHours = acf.opening_hours; lbSources.push('acf'); }
+    }
+  } catch (_e) { /* ACF not available */ }
+  // Try Yoast Local SEO options
+  if (!lbData.name) {
+    try {
+      const yoastOpts = await wpApiCall('/yoast/v1/configuration', { basePath: '/wp-json' });
+      if (yoastOpts?.company_name) { lbData.name = yoastOpts.company_name; lbSources.push('yoast'); }
+    } catch (_e) { /* Yoast not available */ }
+  }
+  // Fallback to WP options
+  try {
+    const wpOpts = await wpApiCall('/settings', { basePath: '/wp-json/wp/v2' });
+    if (!lbData.name && wpOpts.title) { lbData.name = wpOpts.title; lbSources.push('wp_options'); }
+    if (!lbData.email && wpOpts.email) { lbData.email = wpOpts.email; lbSources.push('wp_options'); }
+    if (!lbData.url) { lbData.url = wpOpts.url || wpOpts.home; lbSources.push('wp_options'); }
+  } catch (_e) {
+    try { const si = await wpApiCall('/', { basePath: '/wp-json' }); if (!lbData.name && si.name) { lbData.name = si.name; lbSources.push('wp_site_info'); } if (!lbData.url && si.url) { lbData.url = si.url; } } catch (_e2) { /* ignore */ }
+  }
+  if (!lbData.name) lbMissing.push('name (business_name)');
+  if (!lbData.address) lbMissing.push('address');
+  if (!lbData.telephone) lbMissing.push('telephone');
+  if (!lbData.email) lbMissing.push('email');
+  if (!lbData.openingHours) lbMissing.push('openingHours');
+  const lbSchema = { '@context': 'https://schema.org', '@type': 'LocalBusiness' };
+  if (lbData.name) lbSchema.name = lbData.name;
+  if (lbData.url) lbSchema.url = lbData.url;
+  if (lbData.telephone) lbSchema.telephone = lbData.telephone;
+  if (lbData.email) lbSchema.email = lbData.email;
+  if (lbData.address) {
+    if (typeof lbData.address === 'string') lbSchema.address = lbData.address;
+    else lbSchema.address = { '@type': 'PostalAddress', ...lbData.address };
+  }
+  if (lbData.openingHours) lbSchema.openingHoursSpecification = lbData.openingHours;
+  result = json({ jsonld: lbSchema, sources: [...new Set(lbSources)], fields_missing: lbMissing, recommendations: lbMissing.map(f => `Add ${f} via ACF custom fields or Yoast Local SEO for richer LocalBusiness schema.`) });
+  auditLog({ tool: name, action: 'generate_schema_localbusiness', status: 'success', latency_ms: Date.now() - t0, params: { target: lbTarget } });
+  return result;
+};
+handlers['wp_generate_schema_breadcrumb'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, auditLog, name } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 } });
+  const bcPost = await wpApiCall(`/posts/${args.post_id}?_embed=true`).catch(() => null);
+  const bcPage = !bcPost ? await wpApiCall(`/pages/${args.post_id}?_embed=true`) : null;
+  const bcItem = bcPost || bcPage;
+  if (!bcItem) throw new Error(`Post or page ${args.post_id} not found.`);
+  const { url: bcSiteUrl } = getActiveAuth();
+  const bcItems = [{ name: 'Home', url: bcSiteUrl }];
+  const bcType = bcPost ? 'post' : 'page';
+  if (bcType === 'post') {
+    // Post: Home > Category > Post
+    const catIds = bcItem.categories || [];
+    if (catIds.length > 0) {
+      try {
+        const cat = await wpApiCall(`/categories/${catIds[0]}`);
+        if (cat.parent && cat.parent > 0) {
+          try {
+            const parentCat = await wpApiCall(`/categories/${cat.parent}`);
+            bcItems.push({ name: strip(parentCat.name), url: parentCat.link });
+          } catch (_e) { /* skip parent */ }
+        }
+        bcItems.push({ name: strip(cat.name), url: cat.link });
+      } catch (_e) { /* no category */ }
+    }
+  } else {
+    // Page: Home > Parent pages > Page
+    let parentId = bcItem.parent;
+    const parentChain = [];
+    while (parentId && parentId > 0) {
+      try {
+        const parentPage = await wpApiCall(`/pages/${parentId}`);
+        parentChain.unshift({ name: strip(parentPage.title?.rendered || ''), url: parentPage.link });
+        parentId = parentPage.parent;
+      } catch (_e) { break; }
+    }
+    bcItems.push(...parentChain);
+  }
+  bcItems.push({ name: strip(bcItem.title?.rendered || ''), url: bcItem.link });
+  const bcSchema = {
+    '@context': 'https://schema.org', '@type': 'BreadcrumbList',
+    itemListElement: bcItems.map((item, i) => ({ '@type': 'ListItem', position: i + 1, name: item.name, item: item.url }))
+  };
+  const bcPath = bcItems.map(i => i.name).join(' > ');
+  result = json({ jsonld: bcSchema, path: bcPath, item_count: bcItems.length });
+  auditLog({ tool: name, action: 'generate_schema_breadcrumb', status: 'success', latency_ms: Date.now() - t0, params: { post_id: args.post_id } });
+  return result;
+};
+handlers['wp_inject_schema'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveControls, auditLog, name, handleToolCall } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 }, schema_type: { type: 'string', required: true, enum: ['article', 'faq', 'howto', 'localbusiness', 'breadcrumb'] } });
+  const { post_id: injPostId, schema_type: injType, override = false, dry_run = false } = args;
+  // Enforce read-only UNLESS dry_run
+  if (!dry_run && getActiveControls().read_only) {
+    throw new Error('Blocked: Server is in READ-ONLY mode (WP_READ_ONLY=true). Tool "wp_inject_schema" is not allowed. Use dry_run=true to preview.');
+  }
+  // Generate schema via internal call
+  const genToolName = `wp_generate_schema_${injType}`;
+  const genArgs = injType === 'localbusiness' ? { target: String(injPostId) } : { post_id: injPostId };
+  const genResult = await handleToolCall({ params: { name: genToolName, arguments: genArgs } });
+  const genData = JSON.parse(genResult.content[0].text);
+  const injJsonLd = genData.jsonld;
+  if (dry_run) {
+    result = json({ dry_run: true, status: 'preview', post_id: injPostId, schema_type: injType, jsonld: injJsonLd, validation_url: `https://validator.schema.org/#url=${encodeURIComponent('')}` });
+    auditLog({ tool: name, action: 'inject_schema', status: 'dry_run', latency_ms: Date.now() - t0, params: { post_id: injPostId, schema_type: injType } });
+    return result;
+  }
+  // Check for existing meta
+  try {
+    const existingMeta = await wpApiCall(`/schema/${injPostId}`, { basePath: '/wp-json/mcp-diagnostics/v1' });
+    if (existingMeta && existingMeta.schema && !override) {
+      result = { content: [{ type: 'text', text: JSON.stringify({ error: 'Schema already exists. Use override=true to replace.', existing_schema: existingMeta.schema }, null, 2) }], isError: true };
+      auditLog({ tool: name, action: 'inject_schema', status: 'blocked_existing', latency_ms: Date.now() - t0, params: { post_id: injPostId, schema_type: injType } });
+      return result;
+    }
+  } catch (_e) { /* No existing meta or endpoint not available, proceed */ }
+  // Inject via mu-plugin endpoint or via post meta
+  try {
+    await wpApiCall(`/schema/${injPostId}`, { method: 'POST', body: JSON.stringify({ schema: JSON.stringify(injJsonLd) }), basePath: '/wp-json/mcp-diagnostics/v1' });
+  } catch (_e) {
+    // Fallback: update post meta directly via REST
+    await wpApiCall(`/posts/${injPostId}`, { method: 'POST', body: JSON.stringify({ meta: { _custom_schema_jsonld: JSON.stringify(injJsonLd) } }) });
+  }
+  result = json({ status: 'injected', post_id: injPostId, schema_type: injType, jsonld: injJsonLd });
+  auditLog({ tool: name, action: 'inject_schema', status: 'success', latency_ms: Date.now() - t0, params: { post_id: injPostId, schema_type: injType, override } });
+  return result;
+};
+handlers['wp_validate_schema_live'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { fetch, auditLog, name } = rt;
+  validateInput(args, { url: { type: 'string', required: true } });
+  const valUrl = args.url;
+  const valResp = await fetch(valUrl, { headers: { 'User-Agent': 'WordPress-MCP-Server' }, redirect: 'follow' });
+  if (!valResp.ok) throw new Error(`Failed to fetch ${valUrl}: HTTP ${valResp.status}`);
+  const valHtml = await valResp.text();
+  // Extract all JSON-LD blocks
+  const ldRe = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  let ldMatch;
+  const schemas = [];
+  while ((ldMatch = ldRe.exec(valHtml)) !== null) {
+    try {
+      const parsed = JSON.parse(ldMatch[1]);
+      schemas.push(parsed);
+    } catch (_e) {
+      schemas.push({ _raw: ldMatch[1].substring(0, 500), _parse_error: true });
+    }
+  }
+  // Validate each schema
+  const requiredFields = {
+    Article: ['headline', 'author'],
+    FAQPage: ['mainEntity'],
+    HowTo: ['step', 'name'],
+    LocalBusiness: ['name'],
+    BreadcrumbList: ['itemListElement'],
+    Product: ['name'],
+    WebSite: ['name', 'url'],
+    Organization: ['name'],
+  };
+  const validatedSchemas = schemas.map(s => {
+    if (s._parse_error) return { type: 'unknown', valid: false, errors: ['Invalid JSON'], warnings: [] };
+    const isGraph = Array.isArray(s['@graph']);
+    const items = isGraph ? s['@graph'] : [s];
+    return items.map(item => {
+      const type = item['@type'] || 'unknown';
+      const errors = [];
+      const warnings = [];
+      // @context is on the parent for @graph items
+      if (!item['@context'] && !isGraph) errors.push('Missing @context');
+      const reqFields = requiredFields[type] || [];
+      reqFields.forEach(f => { if (!item[f]) errors.push(`Missing required field: ${f}`); });
+      // Check common issues
+      if (item.url && !item.url.startsWith('http')) warnings.push('Relative URL detected in url field');
+      if (item.datePublished && isNaN(Date.parse(item.datePublished))) warnings.push('Invalid datePublished format');
+      if (item.dateModified && isNaN(Date.parse(item.dateModified))) warnings.push('Invalid dateModified format');
+      if (item.image && typeof item.image === 'string' && !item.image.startsWith('http')) warnings.push('Relative URL in image field');
+      Object.keys(item).forEach(k => { if (item[k] === '' || item[k] === null) warnings.push(`Empty field: ${k}`); });
+      return { type, valid: errors.length === 0, errors, warnings };
+    });
+  }).flat();
+  const richResults = { article: false, faq: false, howto: false, breadcrumb: false, localbusiness: false };
+  validatedSchemas.forEach(s => {
+    if (s.valid) {
+      const t = s.type.toLowerCase();
+      if (t === 'article' || t === 'newsarticle' || t === 'blogposting') richResults.article = true;
+      if (t === 'faqpage') richResults.faq = true;
+      if (t === 'howto') richResults.howto = true;
+      if (t === 'breadcrumblist') richResults.breadcrumb = true;
+      if (t === 'localbusiness') richResults.localbusiness = true;
+    }
+  });
+  const valRecs = [];
+  if (schemas.length === 0) valRecs.push('No JSON-LD schemas found. Add structured data to improve SEO.');
+  validatedSchemas.filter(s => !s.valid).forEach(s => valRecs.push(`Fix ${s.type}: ${s.errors.join(', ')}`));
+  if (!richResults.article && !richResults.faq && !richResults.howto) valRecs.push('Consider adding Article, FAQ, or HowTo schema for rich results eligibility.');
+  result = json({ url: valUrl, schemas_found: validatedSchemas, total_schemas: schemas.length, rich_results_eligible: richResults, validation_source: 'local', recommendations: valRecs });
+  auditLog({ tool: name, action: 'validate_schema_live', status: 'success', latency_ms: Date.now() - t0, params: { url: valUrl } });
+  return result;
+};