@adsim/wordpress-mcp-server 4.5.1 → 5.1.0

package/src/tools/links.js

@@ -0,0 +1,118 @@
+// src/tools/links.js — links tools (2)
+// 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_analyze_links', _category: 'links', description: 'Use to audit all internal and external links in a single post via HEAD requests. Returns broken/warning/ok status per link. Read-only.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number' }, check_broken: { type: 'boolean', default: true, description: 'Check broken internal links via HEAD request' }, timeout_ms: { type: 'number', default: 5000, description: 'Timeout per HEAD request in ms' } }, required: ['post_id'] }},
+  { name: 'wp_suggest_internal_links', _category: 'links', description: 'Use to get scored internal link suggestions for a post based on keyword relevance, categories, and freshness. Read-only. Hint: call wp_get_post with content_format=\'links_only\' first to map existing links.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number' }, max_suggestions: { type: 'number', default: 5, description: 'Number of suggestions (1-10)' }, focus_keywords: { type: 'array', items: { type: 'string' }, description: 'Additional keywords to match against' }, exclude_already_linked: { type: 'boolean', default: true, description: 'Exclude posts already linked from the current post' } }, required: ['post_id'] }}
+];
+
+export const handlers = {};
+
+handlers['wp_analyze_links'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, auditLog, name, extractInternalLinks, extractExternalLinks, checkLinkStatus } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 }, timeout_ms: { type: 'number', min: 100 } });
+  const { post_id, check_broken = true, timeout_ms = 5000 } = args;
+  const p = await wpApiCall(`/posts/${post_id}`);
+  const content = p.content?.rendered || '';
+  const postTitle = strip(p.title?.rendered || '');
+  const { url: siteUrl } = getActiveAuth();
+  const internal_links = extractInternalLinks(content, siteUrl);
+  const external_links = extractExternalLinks(content, siteUrl);
+  let broken_count = 0, warning_count = 0, unknown_count = 0;
+  if (check_broken) {
+    const toCheck = internal_links.slice(0, 20);
+    for (const link of toCheck) {
+      const fullUrl = link.url.startsWith('/') ? `${siteUrl}${link.url}` : link.url;
+      const { status, http_code } = await checkLinkStatus(fullUrl, timeout_ms);
+      link.status = status;
+      link.http_code = http_code;
+      if (status === 'broken') broken_count++;
+      else if (status === 'warning') warning_count++;
+      else if (status === 'unknown') unknown_count++;
+    }
+    for (let i = 20; i < internal_links.length; i++) {
+      internal_links[i].status = 'unchecked';
+      internal_links[i].http_code = null;
+    }
+  } else {
+    for (const link of internal_links) { link.status = 'unchecked'; link.http_code = null; }
+  }
+  result = json({
+    post_id, post_title: postTitle, internal_links, external_links,
+    summary: { total_internal: internal_links.length, total_external: external_links.length, broken_count, warning_count, unknown_count }
+  });
+  auditLog({ tool: name, target: post_id, target_type: 'post', action: 'analyze_links', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};
+handlers['wp_suggest_internal_links'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, auditLog, name, extractInternalLinks, extractFocusKeyword, calculateRelevanceScore, suggestAnchorText } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 }, max_suggestions: { type: 'number', min: 1, max: 10 } });
+  const { post_id, max_suggestions = 5, focus_keywords = [], exclude_already_linked = true } = args;
+  const p = await wpApiCall(`/posts/${post_id}`);
+  const content = p.content?.rendered || '';
+  const postTitle = strip(p.title?.rendered || '');
+  const postMeta = p.meta || {};
+  const postCategories = p.categories || [];
+  const { url: siteUrl } = getActiveAuth();
+
+  // Step 1 — Collect keywords
+  const seoKeyword = extractFocusKeyword(postMeta);
+  let keywords = [...(Array.isArray(focus_keywords) ? focus_keywords : [])];
+  if (seoKeyword) keywords.unshift(seoKeyword);
+  keywords = [...new Set(keywords.map(k => k.toLowerCase()))];
+  if (keywords.length === 0) {
+    keywords = postTitle.split(/\s+/).slice(0, 5).filter(w => w.length > 2).map(w => w.toLowerCase());
+  }
+
+  // Already-linked URLs
+  const linkedUrls = siteUrl ? extractInternalLinks(content, siteUrl).map(l => l.url) : [];
+
+  // Step 2 — Search for candidates (max 3 keyword searches)
+  const candidateMap = new Map();
+  for (const kw of keywords.slice(0, 3)) {
+    try {
+      const results = await wpApiCall(`/posts?search=${encodeURIComponent(kw)}&per_page=10&status=publish`);
+      if (Array.isArray(results)) {
+        for (const r of results) {
+          if (r.id !== post_id && !candidateMap.has(r.id)) candidateMap.set(r.id, r);
+        }
+      }
+    } catch { /* search failed */ }
+  }
+
+  // Step 3 — Score each candidate
+  const currentPostData = { id: post_id, categories: postCategories, linkedUrls: exclude_already_linked ? linkedUrls : [] };
+  const scored = [];
+  let excluded_count = 0;
+
+  for (const [, cand] of candidateMap) {
+    const candTitle = typeof cand.title === 'string' ? cand.title : (cand.title?.rendered || '');
+    const { total, breakdown } = calculateRelevanceScore(
+      { id: cand.id, title: candTitle, date: cand.date, categories: cand.categories || [], meta: cand.meta || {}, link: cand.link || '' },
+      currentPostData, keywords
+    );
+    if (total === -999) { excluded_count++; continue; }
+    scored.push({
+      target_post_id: cand.id, target_title: strip(candTitle), target_url: cand.link || '',
+      anchor_text: suggestAnchorText({ meta: cand.meta || {}, title: candTitle }),
+      relevance_score: total, score_breakdown: breakdown,
+      already_linked: linkedUrls.some(u => u === cand.link)
+    });
+  }
+
+  scored.sort((a, b) => b.relevance_score - a.relevance_score);
+  const suggestions = scored.slice(0, Math.min(max_suggestions, 10));
+  result = json({ post_id, post_title: postTitle, keywords_used: keywords, suggestions, excluded_already_linked: excluded_count });
+  auditLog({ tool: name, target: post_id, target_type: 'post', action: 'suggest_links', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};

package/src/tools/media.js

@@ -0,0 +1,71 @@
+// src/tools/media.js — media tools (3)
+// Definitions + handlers (v5.0.0 refactor Step B+C)
+
+import { json, strip, buildPaginationMeta } from '../shared/utils.js';
+import { validateInput } from '../shared/governance.js';
+import { rt } from '../shared/context.js';
+
+export const definitions = [
+  { name: 'wp_list_media', _category: 'media', description: 'Use to browse media library by type (image/video/audio). Returns id, URL, alt_text, dimensions. Read-only. Hint: use mode=\'summary\' for listings, \'ids_only\' for batch ops.', inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 10 }, page: { type: 'number', default: 1 }, media_type: { type: 'string' }, search: { type: 'string' }, orderby: { type: 'string', default: 'date' }, order: { type: 'string', default: 'desc' }, mode: { type: 'string', enum: ['full', 'summary', 'ids_only'], default: 'full', description: 'full=all fields, summary=key fields only, ids_only=flat ID array' } }}},
+  { name: 'wp_get_media', _category: 'media', description: 'Use to get full media details with all available sizes. Read-only.', inputSchema: { type: 'object', properties: { id: { type: 'number' } }, required: ['id'] }},
+  { name: 'wp_upload_media', _category: 'media', description: 'Use to upload a file from a public URL to the media library. Set alt_text for image SEO. Write — blocked by WP_READ_ONLY.', inputSchema: { type: 'object', properties: { url: { type: 'string' }, filename: { type: 'string' }, title: { type: 'string' }, alt_text: { type: 'string' }, caption: { type: 'string' }, description: { type: 'string' }, post_id: { type: 'number' } }, required: ['url'] }}
+];
+
+export const handlers = {};
+
+handlers['wp_list_media'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, ORDERS, MEDIA_TYPES } = rt;
+  validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, page: { type: 'number', min: 1 }, media_type: { type: 'string', enum: MEDIA_TYPES }, order: { type: 'string', enum: ORDERS }, mode: { type: 'string', enum: ['full', 'summary', 'ids_only'] } });
+  const { per_page = 10, page = 1, media_type, search, orderby = 'date', order = 'desc', mode = 'full' } = args;
+  let ep = `/media?per_page=${per_page}&page=${page}&orderby=${orderby}&order=${order}`;
+  if (media_type) ep += `&media_type=${media_type}`; if (search) ep += `&search=${encodeURIComponent(search)}`;
+  const media = await wpApiCall(ep);
+  const mediaPg = media._wpTotal !== undefined ? buildPaginationMeta(media._wpTotal, page, per_page) : undefined;
+  if (mode === 'ids_only') {
+    result = json({ total: media.length, page, mode: 'ids_only', ids: media.map(m => m.id), ...(mediaPg && { pagination: mediaPg }) });
+    auditLog({ tool: name, action: 'list', status: 'success', latency_ms: Date.now() - t0 });
+    return result;
+  }
+  if (mode === 'summary') {
+    result = json({ total: media.length, page, mode: 'summary', media: media.map(m => ({ id: m.id, title: m.title.rendered, mime_type: m.mime_type, source_url: m.source_url, alt_text: m.alt_text })), ...(mediaPg && { pagination: mediaPg }) });
+    auditLog({ tool: name, action: 'list', status: 'success', latency_ms: Date.now() - t0 });
+    return result;
+  }
+  result = json({ total: media.length, page, media: media.map(m => ({ id: m.id, title: m.title.rendered, date: m.date, mime_type: m.mime_type, source_url: m.source_url, alt_text: m.alt_text, width: m.media_details?.width, height: m.media_details?.height })), ...(mediaPg && { pagination: mediaPg }) });
+  auditLog({ tool: name, action: 'list', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};
+handlers['wp_get_media'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+  const m = await wpApiCall(`/media/${args.id}`);
+  const sizes = m.media_details?.sizes || {};
+  result = json({ id: m.id, title: m.title.rendered, date: m.date, mime_type: m.mime_type, source_url: m.source_url, alt_text: m.alt_text, caption: strip(m.caption?.rendered), width: m.media_details?.width, height: m.media_details?.height, file: m.media_details?.file, sizes: Object.fromEntries(Object.entries(sizes).map(([k, v]) => [k, { url: v.source_url, width: v.width, height: v.height }])) });
+  auditLog({ tool: name, target: args.id, target_type: 'media', action: 'read', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};
+handlers['wp_upload_media'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, TIMEOUT_MS, fetch, auditLog, name } = rt;
+  validateInput(args, { url: { type: 'string', required: true } });
+  const { url: fileUrl, filename, title, alt_text, caption, description, post_id } = args;
+  const dlResp = await fetch(fileUrl, { timeout: TIMEOUT_MS });
+  if (!dlResp.ok) throw new Error(`Download failed: ${dlResp.status}`);
+  const fileBuffer = await dlResp.buffer();
+  const contentType = dlResp.headers.get('content-type') || 'application/octet-stream';
+  const fname = filename || fileUrl.split('/').pop().split('?')[0] || 'upload';
+  let ep = '/media'; if (post_id) ep += `?post=${post_id}`;
+  const uploaded = await wpApiCall(ep, { method: 'POST', body: fileBuffer, isMultipart: true, headers: { 'Content-Type': contentType, 'Content-Disposition': `attachment; filename="${fname}"` } });
+  if (title || alt_text || caption || description) {
+    const md = {}; if (title) md.title = title; if (alt_text) md.alt_text = alt_text; if (caption) md.caption = caption; if (description) md.description = description;
+    await wpApiCall(`/media/${uploaded.id}`, { method: 'POST', body: JSON.stringify(md) });
+  }
+  result = json({ success: true, message: `Uploaded: ${fname}`, media: { id: uploaded.id, source_url: uploaded.source_url, mime_type: uploaded.mime_type } });
+  auditLog({ tool: name, target: uploaded.id, target_type: 'media', action: 'upload', status: 'success', latency_ms: Date.now() - t0, params: { filename: fname } });
+  return result;
+};

package/src/tools/performance.js

@@ -0,0 +1,219 @@
+// src/tools/performance.js — performance tools (6)
+// Definitions + handlers (v5.0.0 refactor Step B+C)
+
+import { json } from '../shared/utils.js';
+import { validateInput } from '../shared/governance.js';
+import { rt } from '../shared/context.js';
+
+export const definitions = [
+  { name: 'wp_audit_page_speed', _category: 'performance', description: 'Use to run a Google PageSpeed Insights audit. Returns Core Web Vitals (LCP, CLS, INP, FCP, TTFB), overall score, and optimization opportunities sorted by impact. Requires PAGESPEED_API_KEY env var. Read-only.',
+        inputSchema: { type: 'object', properties: { url: { type: 'string', description: 'URL to audit (full URL)' }, strategy: { type: 'string', enum: ['mobile', 'desktop'], description: 'Test strategy (default mobile)' } }, required: ['url'] }},
+  { name: 'wp_find_render_blocking_resources', _category: 'performance', description: 'Use to detect render-blocking CSS and JS in the <head> of a page. Fetches the page HTML and identifies <link rel="stylesheet"> and <script> tags without defer/async. Read-only.',
+        inputSchema: { type: 'object', properties: { url: { type: 'string', description: 'URL to analyze (defaults to site homepage)' } }}},
+  { name: 'wp_audit_image_optimization', _category: 'performance', description: 'Use to audit media library images for optimization issues: non-WebP format, large file size (>100KB), missing alt text. Read-only.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', description: 'default 50, max 100' }, min_size_kb: { type: 'number', description: 'default 100KB' } }}},
+  { name: 'wp_check_caching_status', _category: 'performance', description: 'Use to check if a caching plugin is active (WP Rocket, W3 Total Cache, LiteSpeed, WP Super Cache, Autoptimize) and detect cache-related HTTP headers on the homepage. Read-only.',
+        inputSchema: { type: 'object', properties: {} }},
+  { name: 'wp_audit_database_bloat', _category: 'performance', description: 'Use to audit database for bloat: revision count, expired transients, auto-drafts, spam/trash, orphan postmeta, table sizes. Requires mcp-diagnostics companion mu-plugin. Read-only.',
+        inputSchema: { type: 'object', properties: {} }},
+  { name: 'wp_get_plugin_performance_impact', _category: 'performance', description: 'Use to estimate the performance impact of active plugins. Cross-references active plugins with a known impact database (~50 plugins). Returns plugins ranked by estimated load time impact. Read-only.',
+        inputSchema: { type: 'object', properties: {} }}
+];
+
+export const handlers = {};
+
+handlers['wp_audit_page_speed'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { fetch, auditLog, name } = rt;
+  validateInput(args, { url: { type: 'string', required: true }, strategy: { type: 'string', enum: ['mobile', 'desktop'] } });
+  const { url: pageUrl, strategy = 'mobile' } = args;
+  const apiKey = process.env.PAGESPEED_API_KEY;
+  if (!apiKey) throw new Error('PAGESPEED_API_KEY environment variable is required. Get a free key at https://developers.google.com/speed/docs/insights/v5/get-started');
+  const psiUrl = `https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=${encodeURIComponent(pageUrl)}&strategy=${strategy}&key=${apiKey}`;
+  const psiResp = await fetch(psiUrl, { headers: { 'User-Agent': 'WordPress-MCP-Server' } });
+  if (!psiResp.ok) {
+    const errText = await psiResp.text();
+    throw new Error(`PageSpeed API ${psiResp.status}: ${errText.substring(0, 300)}`);
+  }
+  const psi = await psiResp.json();
+  const lhr = psi.lighthouseResult || {};
+  const lhrAudits = lhr.audits || {};
+  const lhrCategories = lhr.categories || {};
+  const perfScore = Math.round((lhrCategories.performance?.score || 0) * 100);
+  const cwvMetrics = {
+    lcp: lhrAudits['largest-contentful-paint']?.displayValue || 'N/A',
+    lcp_score: lhrAudits['largest-contentful-paint']?.score,
+    cls: lhrAudits['cumulative-layout-shift']?.displayValue || 'N/A',
+    cls_score: lhrAudits['cumulative-layout-shift']?.score,
+    inp: lhrAudits['interaction-to-next-paint']?.displayValue || lhrAudits['max-potential-fid']?.displayValue || 'N/A',
+    inp_score: lhrAudits['interaction-to-next-paint']?.score || lhrAudits['max-potential-fid']?.score,
+    fcp: lhrAudits['first-contentful-paint']?.displayValue || 'N/A',
+    fcp_score: lhrAudits['first-contentful-paint']?.score,
+    ttfb: lhrAudits['server-response-time']?.displayValue || 'N/A',
+    ttfb_score: lhrAudits['server-response-time']?.score,
+    speed_index: lhrAudits['speed-index']?.displayValue || 'N/A',
+    tbt: lhrAudits['total-blocking-time']?.displayValue || 'N/A'
+  };
+  const opportunities = Object.values(lhrAudits)
+    .filter(a => a.details?.type === 'opportunity' && a.details?.overallSavingsMs > 0)
+    .sort((a, b) => (b.details.overallSavingsMs || 0) - (a.details.overallSavingsMs || 0))
+    .map(a => ({ title: a.title, savings_ms: a.details.overallSavingsMs, savings_bytes: a.details.overallSavingsBytes || 0, description: a.description?.substring(0, 200) }));
+  result = json({ url: pageUrl, strategy, score: perfScore, metrics: cwvMetrics, opportunities_count: opportunities.length, opportunities });
+  auditLog({ tool: name, action: 'audit', status: 'success', latency_ms: Date.now() - t0, params: { url: pageUrl, strategy } });
+  return result;
+};
+handlers['wp_find_render_blocking_resources'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { getActiveAuth, fetch, auditLog, name } = rt;
+  const { url: rbUrl } = args;
+  const { url: siteUrl } = getActiveAuth();
+  const targetUrl = rbUrl || siteUrl;
+  const htmlResp = await fetch(targetUrl, { headers: { 'User-Agent': 'WordPress-MCP-Server' }, redirect: 'follow' });
+  if (!htmlResp.ok) throw new Error(`Failed to fetch ${targetUrl}: HTTP ${htmlResp.status}`);
+  const html = await htmlResp.text();
+  const headMatch = html.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+  const headHtml = headMatch ? headMatch[1] : '';
+  const blocking = [];
+  const cssRegex = /<link[^>]*rel=["']stylesheet["'][^>]*>/gi;
+  let cssMatch;
+  while ((cssMatch = cssRegex.exec(headHtml)) !== null) {
+    const tag = cssMatch[0];
+    if (/media=["']print["']/i.test(tag)) continue;
+    if (/disabled/i.test(tag)) continue;
+    const hrefMatch = tag.match(/href=["']([^"']+)["']/i);
+    if (hrefMatch) blocking.push({ type: 'css', url: hrefMatch[1], tag: tag.substring(0, 150) });
+  }
+  const jsRegex = /<script[^>]*src=["'][^"']+["'][^>]*>/gi;
+  let jsMatch;
+  while ((jsMatch = jsRegex.exec(headHtml)) !== null) {
+    const tag = jsMatch[0];
+    if (/\b(defer|async)\b/i.test(tag)) continue;
+    if (/type=["']module["']/i.test(tag)) continue;
+    const srcMatch = tag.match(/src=["']([^"']+)["']/i);
+    if (srcMatch) blocking.push({ type: 'js', url: srcMatch[1], tag: tag.substring(0, 150) });
+  }
+  result = json({ url: targetUrl, total_blocking: blocking.length, blocking_css: blocking.filter(b => b.type === 'css').length, blocking_js: blocking.filter(b => b.type === 'js').length, resources: blocking });
+  auditLog({ tool: name, action: 'audit', status: 'success', latency_ms: Date.now() - t0, params: { url: targetUrl } });
+  return result;
+};
+handlers['wp_audit_image_optimization'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  const { per_page: imgPerPage = 50, min_size_kb = 100 } = args;
+  validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, min_size_kb: { type: 'number', min: 1 } });
+  const mediaItems = await wpApiCall(`/media?per_page=${Math.min(imgPerPage, 100)}&media_type=image&orderby=date&order=desc`);
+  const imgIssues = [];
+  for (const m of mediaItems) {
+    const problems = [];
+    const src = m.source_url || '';
+    const mime = m.mime_type || '';
+    const alt = m.alt_text || '';
+    const fileSize = m.media_details?.filesize || 0;
+    const sizeKb = Math.round(fileSize / 1024);
+    if (mime && !mime.includes('webp') && !mime.includes('avif') && !mime.includes('svg')) {
+      problems.push({ issue: 'not_modern_format', detail: `Format: ${mime}. Consider converting to WebP.` });
+    }
+    if (sizeKb > min_size_kb) {
+      problems.push({ issue: 'large_file', detail: `${sizeKb}KB exceeds ${min_size_kb}KB threshold.` });
+    }
+    if (!alt || alt.trim().length === 0) {
+      problems.push({ issue: 'missing_alt_text', detail: 'No alt text set. Bad for SEO and accessibility.' });
+    } else if (alt.trim().length < 5) {
+      problems.push({ issue: 'short_alt_text', detail: `Alt text too short (${alt.trim().length} chars).` });
+    }
+    if (problems.length > 0) {
+      imgIssues.push({ id: m.id, filename: src.split('/').pop(), url: src, size_kb: sizeKb, mime_type: mime, alt_text: alt || null, problems, priority: problems.length >= 3 ? 'high' : problems.length === 2 ? 'medium' : 'low' });
+    }
+  }
+  imgIssues.sort((a, b) => { const p = { high: 3, medium: 2, low: 1 }; return p[b.priority] - p[a.priority]; });
+  result = json({ total_audited: mediaItems.length, issues_found: imgIssues.length, by_priority: { high: imgIssues.filter(i => i.priority === 'high').length, medium: imgIssues.filter(i => i.priority === 'medium').length, low: imgIssues.filter(i => i.priority === 'low').length }, images: imgIssues });
+  auditLog({ tool: name, action: 'audit', status: 'success', latency_ms: Date.now() - t0, params: { per_page: imgPerPage, min_size_kb } });
+  return result;
+};
+handlers['wp_check_caching_status'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, fetch, auditLog, name } = rt;
+  const allPlugins = await wpApiCall('/plugins');
+  const knownCachePlugins = {
+    'wp-rocket/wp-rocket.php': 'WP Rocket',
+    'w3-total-cache/w3-total-cache.php': 'W3 Total Cache',
+    'litespeed-cache/litespeed-cache.php': 'LiteSpeed Cache',
+    'wp-super-cache/wp-cache.php': 'WP Super Cache',
+    'autoptimize/autoptimize.php': 'Autoptimize',
+    'wp-fastest-cache/wpFastestCache.php': 'WP Fastest Cache',
+    'breeze/breeze.php': 'Breeze',
+    'sg-cachepress/sg-cachepress.php': 'SG Optimizer',
+    'nitropack/main.php': 'NitroPack',
+    'cache-enabler/cache-enabler.php': 'Cache Enabler'
+  };
+  const detectedCachePlugins = [];
+  if (Array.isArray(allPlugins)) {
+    for (const p of allPlugins) {
+      const slug = p.plugin || '';
+      if (knownCachePlugins[slug]) {
+        detectedCachePlugins.push({ plugin: slug, name: knownCachePlugins[slug], version: p.version, status: p.status });
+      }
+    }
+  }
+  const { url: homeUrl } = getActiveAuth();
+  let cacheHeaders = {};
+  try {
+    const headResp = await fetch(homeUrl, { method: 'HEAD', headers: { 'User-Agent': 'WordPress-MCP-Server' }, redirect: 'follow' });
+    const headerNames = ['x-cache', 'cf-cache-status', 'x-varnish', 'x-proxy-cache', 'x-litespeed-cache', 'x-wp-cf-super-cache', 'cache-control', 'x-fastcgi-cache', 'x-sucuri-cache', 'server-timing', 'x-kinsta-cache', 'x-cache-enabled'];
+    for (const h of headerNames) {
+      const val = headResp.headers.get(h);
+      if (val) cacheHeaders[h] = val;
+    }
+  } catch (e) {
+    cacheHeaders = { error: `Could not fetch homepage headers: ${e.message}` };
+  }
+  const hasActiveCache = detectedCachePlugins.some(p => p.status === 'active');
+  const hasCacheHeaders = Object.keys(cacheHeaders).length > 0 && !cacheHeaders.error;
+  result = json({ caching_detected: hasActiveCache || hasCacheHeaders, plugins: detectedCachePlugins, http_headers: cacheHeaders, recommendation: !hasActiveCache && !hasCacheHeaders ? 'No caching detected. Install a caching plugin (WP Rocket, LiteSpeed Cache, or WP Super Cache) for significant performance improvement.' : null });
+  auditLog({ tool: name, action: 'check', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};
+handlers['wp_audit_database_bloat'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  const bloatData = await wpApiCall('/database-bloat', { basePath: '/wp-json/mcp-diagnostics/v1' });
+  result = json({ revisions: bloatData.revisions, auto_drafts: bloatData.auto_drafts, trashed_posts: bloatData.trashed_posts, spam_comments: bloatData.spam_comments, trashed_comments: bloatData.trashed_comments, transients_total: bloatData.transients_total, transients_expired: bloatData.transients_expired, orphan_postmeta: bloatData.orphan_postmeta, database_size_mb: bloatData.database_size_mb, tables: bloatData.tables || [], recommendations: bloatData.recommendations || [] });
+  auditLog({ tool: name, action: 'audit', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};
+handlers['wp_get_plugin_performance_impact'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  const perfPlugins = await wpApiCall('/plugins');
+  const activePerfPlugins = Array.isArray(perfPlugins) ? perfPlugins.filter(p => p.status === 'active') : [];
+  let perfDb;
+  try {
+    const { readFileSync } = await import('fs');
+    const { fileURLToPath } = await import('url');
+    const { dirname, join } = await import('path');
+    const currentFile = fileURLToPath(import.meta.url);
+    const currentDir = dirname(currentFile);
+    perfDb = JSON.parse(readFileSync(join(currentDir, '..', 'data', 'plugin-performance-data.json'), 'utf8'));
+  } catch (e) {
+    throw new Error(`Could not load plugin performance database: ${e.message}`);
+  }
+  const pluginDb = perfDb.plugins || {};
+  const perfReport = activePerfPlugins.map(p => {
+    const slug = p.plugin || '';
+    const known = pluginDb[slug];
+    return { plugin: slug, name: p.name || slug, version: p.version, impact: known ? known.impact : null, impact_label: known ? (known.impact <= -2 ? 'positive' : known.impact <= 0 ? 'neutral' : known.impact <= 2 ? 'low' : known.impact <= 3 ? 'moderate' : 'high') : 'unknown', category: known?.category || 'unknown', notes: known?.notes || null };
+  });
+  perfReport.sort((a, b) => (b.impact || 0) - (a.impact || 0));
+  const heavyPlugins = perfReport.filter(r => r.impact !== null && r.impact >= 3);
+  const positivePlugins = perfReport.filter(r => r.impact !== null && r.impact < 0);
+  const unknownPlugins = perfReport.filter(r => r.impact === null);
+  result = json({ total_active: perfReport.length, heavy_count: heavyPlugins.length, positive_count: positivePlugins.length, unknown_count: unknownPlugins.length, plugins: perfReport, summary: heavyPlugins.length > 0 ? `${heavyPlugins.length} plugin(s) with high performance impact: ${heavyPlugins.map(p => p.name).join(', ')}` : 'No high-impact plugins detected.' });
+  auditLog({ tool: name, action: 'audit', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};