@adsim/wordpress-mcp-server 3.1.0 → 4.5.0

package/src/linkUtils.js

@@ -0,0 +1,158 @@
+/**
+ * Link analysis and suggestion utilities for WordPress MCP Server.
+ */
+
+import fetch from 'node-fetch';
+
+/**
+ * Extract internal links from HTML content.
+ * @param {string} htmlContent
+ * @param {string} siteUrl - e.g. https://example.com
+ * @returns {{ url: string, anchor_text: string }[]}
+ */
+export function extractInternalLinks(htmlContent, siteUrl) {
+  const links = [];
+  if (!htmlContent || !siteUrl) return links;
+  let siteHost;
+  try { siteHost = new URL(siteUrl).host; } catch { return links; }
+  const regex = /<a\s[^>]*?href=["']([^"']+)["'][^>]*?>([\s\S]*?)<\/a>/gi;
+  let match;
+  while ((match = regex.exec(htmlContent)) !== null) {
+    const href = match[1];
+    const anchorText = match[2].replace(/<[^>]*>/g, '').trim();
+    try {
+      if (href.startsWith('/') && !href.startsWith('//')) {
+        links.push({ url: href, anchor_text: anchorText });
+      } else if (href.startsWith('http')) {
+        if (new URL(href).host === siteHost) {
+          links.push({ url: href, anchor_text: anchorText });
+        }
+      }
+    } catch { /* invalid URL, skip */ }
+  }
+  return links;
+}
+
+/**
+ * Extract external links from HTML content.
+ * @param {string} htmlContent
+ * @param {string} siteUrl
+ * @returns {{ url: string, anchor_text: string }[]}
+ */
+export function extractExternalLinks(htmlContent, siteUrl) {
+  const links = [];
+  if (!htmlContent || !siteUrl) return links;
+  let siteHost;
+  try { siteHost = new URL(siteUrl).host; } catch { return links; }
+  const regex = /<a\s[^>]*?href=["']([^"']+)["'][^>]*?>([\s\S]*?)<\/a>/gi;
+  let match;
+  while ((match = regex.exec(htmlContent)) !== null) {
+    const href = match[1];
+    const anchorText = match[2].replace(/<[^>]*>/g, '').trim();
+    try {
+      if (href.startsWith('http') && new URL(href).host !== siteHost) {
+        links.push({ url: href, anchor_text: anchorText });
+      }
+    } catch { /* invalid URL, skip */ }
+  }
+  return links;
+}
+
+/**
+ * Check status of a URL via HEAD request.
+ * @param {string} url
+ * @param {number} timeoutMs
+ * @returns {Promise<{ status: string, http_code: number|null }>}
+ */
+export async function checkLinkStatus(url, timeoutMs) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const response = await fetch(url, { method: 'HEAD', signal: controller.signal, redirect: 'follow' });
+    clearTimeout(timer);
+    const code = response.status;
+    if (code >= 200 && code <= 399) return { status: 'ok', http_code: code };
+    if (code === 404) return { status: 'broken', http_code: code };
+    return { status: 'warning', http_code: code };
+  } catch {
+    return { status: 'unknown', http_code: null };
+  }
+}
+
+/**
+ * Extract focus keyword from post meta (auto-detect SEO plugin).
+ * @param {object} meta
+ * @returns {string|null}
+ */
+export function extractFocusKeyword(meta) {
+  if (!meta) return null;
+  if (meta.rank_math_focus_keyword) return meta.rank_math_focus_keyword;
+  if (meta._yoast_wpseo_focuskw) return meta._yoast_wpseo_focuskw;
+  if (meta._seopress_analysis_target_kw) return meta._seopress_analysis_target_kw;
+  if (meta._aioseo_keywords) return meta._aioseo_keywords;
+  return null;
+}
+
+/**
+ * Calculate relevance score for a candidate post.
+ * @param {object} candidate - { id, title, date, categories, meta, link }
+ * @param {object} currentPost - { id, categories, linkedUrls }
+ * @param {string[]} keywords
+ * @returns {{ total: number, breakdown: { category_match, freshness, keyword_match, title_match } }}
+ */
+export function calculateRelevanceScore(candidate, currentPost, keywords) {
+  let category_match = 0;
+  let freshness = 0;
+  let keyword_match = 0;
+  let title_match = 0;
+
+  // Already linked → excluded
+  if (currentPost.linkedUrls && currentPost.linkedUrls.length > 0 && candidate.link) {
+    if (currentPost.linkedUrls.some(u => u === candidate.link)) {
+      return { total: -999, breakdown: { category_match, freshness, keyword_match, title_match } };
+    }
+  }
+
+  // +3 per common category
+  if (candidate.categories && currentPost.categories) {
+    const common = candidate.categories.filter(c => currentPost.categories.includes(c));
+    category_match = common.length * 3;
+  }
+
+  // Freshness
+  if (candidate.date) {
+    const monthsAgo = (Date.now() - new Date(candidate.date).getTime()) / (1000 * 60 * 60 * 24 * 30);
+    if (monthsAgo < 3) freshness = 3;
+    else if (monthsAgo < 6) freshness = 2;
+    else if (monthsAgo < 12) freshness = 1;
+  }
+
+  // Focus keyword of candidate contains a search keyword → +2
+  const candidateKw = extractFocusKeyword(candidate.meta);
+  if (candidateKw && keywords && keywords.length > 0) {
+    const lower = candidateKw.toLowerCase();
+    if (keywords.some(k => lower.includes(k.toLowerCase()))) keyword_match = 2;
+  }
+
+  // Keyword present in candidate title → +2
+  if (candidate.title && keywords && keywords.length > 0) {
+    const titleLower = (typeof candidate.title === 'string' ? candidate.title : '').toLowerCase();
+    if (keywords.some(k => titleLower.includes(k.toLowerCase()))) title_match = 2;
+  }
+
+  return { total: category_match + freshness + keyword_match + title_match, breakdown: { category_match, freshness, keyword_match, title_match } };
+}
+
+/**
+ * Suggest anchor text for a candidate post.
+ * @param {object} candidate - { meta, title }
+ * @returns {string}
+ */
+export function suggestAnchorText(candidate) {
+  const focusKw = extractFocusKeyword(candidate.meta);
+  if (focusKw) return focusKw.replace(/<[^>]*>/g, '').trim();
+  let title = typeof candidate.title === 'string' ? candidate.title : (candidate.title?.rendered || '');
+  title = title.replace(/<[^>]*>/g, '').trim();
+  if (title.length > 60) title = title.substring(0, 60).trim();
+  return title;
+}

package/src/pluginDetector.js

@@ -0,0 +1,158 @@
+/**
+ * SEO Plugin Detection & Rendered Head Utilities
+ *
+ * Detects active SEO plugins (RankMath, Yoast, SEOPress) via the WP REST API
+ * discovery endpoint, retrieves the rendered <head> from plugin-specific
+ * headless endpoints, and parses the resulting HTML for SEO meta tags.
+ */
+
+// In-process cache (Map<siteUrl, string|null>)
+const pluginCache = new Map();
+
+/**
+ * Detect which SEO plugin is active on a WordPress site by inspecting
+ * the REST API namespaces exposed at /wp-json/.
+ *
+ * @param {string} siteUrl  Base site URL (no trailing slash)
+ * @param {Function} fetchFn  node-fetch (or compatible)
+ * @returns {Promise<string|null>}  'rankmath' | 'yoast' | 'seopress' | null
+ */
+export async function detectSeoPlugin(siteUrl, fetchFn) {
+  if (pluginCache.has(siteUrl)) return pluginCache.get(siteUrl);
+
+  try {
+    const resp = await fetchFn(`${siteUrl}/wp-json/`, {
+      headers: { 'User-Agent': 'WordPress-MCP-Server' }
+    });
+    if (!resp.ok) { pluginCache.set(siteUrl, null); return null; }
+    const data = await resp.json();
+    const ns = data.namespaces || [];
+
+    let plugin = null;
+    if (ns.includes('rankmath/v1')) plugin = 'rankmath';
+    else if (ns.includes('yoast/v1')) plugin = 'yoast';
+    else if (ns.includes('seopress/v1')) plugin = 'seopress';
+
+    pluginCache.set(siteUrl, plugin);
+    return plugin;
+  } catch {
+    pluginCache.set(siteUrl, null);
+    return null;
+  }
+}
+
+/** Clear the detection cache (for tests). */
+export function _clearPluginCache() {
+  pluginCache.clear();
+}
+
+/**
+ * Retrieve the rendered <head> HTML from a plugin's headless endpoint.
+ *
+ * @param {string} siteUrl      Base site URL
+ * @param {string} postUrl      Full permalink of the post/page
+ * @param {string} plugin       'rankmath' | 'yoast'
+ * @param {Function} fetchFn    node-fetch
+ * @param {string} authBase64   Base64-encoded "user:pass"
+ * @returns {Promise<{success:boolean, head?:string, json?:object, plugin?:string, error?:string}>}
+ */
+export async function getRenderedHead(siteUrl, postUrl, plugin, fetchFn, authBase64) {
+  const authHeader = `Basic ${authBase64}`;
+
+  if (plugin === 'rankmath') {
+    const resp = await fetchFn(`${siteUrl}/wp-json/rankmath/v1/getHead?url=${encodeURIComponent(postUrl)}`, {
+      headers: { 'Authorization': authHeader, 'User-Agent': 'WordPress-MCP-Server' }
+    });
+    if (!resp.ok) return { success: false, error: `RankMath API: ${resp.status}` };
+    const data = await resp.json();
+    return { success: data.success !== false, head: data.head || '', plugin: 'rankmath' };
+  }
+
+  if (plugin === 'yoast') {
+    const resp = await fetchFn(`${siteUrl}/wp-json/yoast/v1/get_head?url=${encodeURIComponent(postUrl)}`, {
+      headers: { 'Authorization': authHeader, 'User-Agent': 'WordPress-MCP-Server' }
+    });
+    if (!resp.ok) return { success: false, error: `Yoast API: ${resp.status}` };
+    const data = await resp.json();
+    return { success: true, head: data.html || '', json: data.json || {}, plugin: 'yoast' };
+  }
+
+  return { success: false, error: `Plugin ${plugin} does not support rendered head` };
+}
+
+/**
+ * Parse a rendered <head> HTML string into structured SEO metadata.
+ *
+ * @param {string} headHtml  Raw HTML from getRenderedHead().head
+ * @returns {object}  Structured metadata
+ */
+export function parseRenderedHead(headHtml) {
+  const result = {
+    title: null,
+    meta_description: null,
+    canonical: null,
+    og_title: null,
+    og_description: null,
+    og_image: null,
+    og_type: null,
+    twitter_card: null,
+    twitter_title: null,
+    twitter_description: null,
+    twitter_image: null,
+    robots: null,
+    schema_json_ld: []
+  };
+
+  if (!headHtml) return result;
+
+  // <title>...</title>
+  const titleMatch = headHtml.match(/<title>([^<]*)<\/title>/i);
+  if (titleMatch) result.title = titleMatch[1].trim();
+
+  // <meta name="description" content="..." />
+  const descMatch = headHtml.match(/<meta\s+name=["']description["']\s+content=["']([^"']*)["']/i);
+  if (descMatch) result.meta_description = descMatch[1];
+
+  // <link rel="canonical" href="..." />
+  const canonMatch = headHtml.match(/<link\s+rel=["']canonical["']\s+href=["']([^"']*)["']/i);
+  if (canonMatch) result.canonical = canonMatch[1];
+
+  // <meta name="robots" content="..." />
+  const robotsMatch = headHtml.match(/<meta\s+name=["']robots["']\s+content=["']([^"']*)["']/i);
+  if (robotsMatch) result.robots = robotsMatch[1];
+
+  // OpenGraph metas
+  const ogPatterns = {
+    og_title: /property=["']og:title["']\s+content=["']([^"']*?)["']/i,
+    og_description: /property=["']og:description["']\s+content=["']([^"']*?)["']/i,
+    og_image: /property=["']og:image["']\s+content=["']([^"']*?)["']/i,
+    og_type: /property=["']og:type["']\s+content=["']([^"']*?)["']/i,
+  };
+  for (const [key, regex] of Object.entries(ogPatterns)) {
+    const m = headHtml.match(regex);
+    if (m) result[key] = m[1];
+  }
+
+  // Twitter metas
+  const twPatterns = {
+    twitter_card: /name=["']twitter:card["']\s+content=["']([^"']*?)["']/i,
+    twitter_title: /name=["']twitter:title["']\s+content=["']([^"']*?)["']/i,
+    twitter_description: /name=["']twitter:description["']\s+content=["']([^"']*?)["']/i,
+    twitter_image: /name=["']twitter:image["']\s+content=["']([^"']*?)["']/i,
+  };
+  for (const [key, regex] of Object.entries(twPatterns)) {
+    const m = headHtml.match(regex);
+    if (m) result[key] = m[1];
+  }
+
+  // JSON-LD schemas
+  const schemaRegex = /<script\s+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  let schemaMatch;
+  while ((schemaMatch = schemaRegex.exec(headHtml)) !== null) {
+    try {
+      result.schema_json_ld.push(JSON.parse(schemaMatch[1]));
+    } catch { /* ignore malformed JSON-LD */ }
+  }
+
+  return result;
+}

package/src/utils/contentCompressor.js

@@ -0,0 +1,116 @@
+/**
+ * Content compression utilities for LLM context optimization.
+ * Reduces token consumption on large WordPress sites.
+ */
+
+const DEFAULT_MAX_CHARS = parseInt(process.env.WP_MAX_CONTENT_CHARS || '15000', 10);
+
+/**
+ * Strip HTML tags and decode common entities.
+ * @param {string} html
+ * @returns {string}
+ */
+export function stripHtml(html) {
+  if (!html) return '';
+  return html
+    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+    .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+    .replace(/<\/?(p|div|h[1-6]|li|br|tr|blockquote|pre)[^>]*>/gi, '\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#039;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/[ \t]+/g, ' ')
+    .trim();
+}
+
+/**
+ * Extract internal links from HTML content.
+ * Returns only links pointing to the same site.
+ * @param {string} html
+ * @param {string} siteUrl  e.g. https://example.com
+ * @returns {{ text: string, href: string }[]}
+ */
+export function extractLinksOnly(html, siteUrl) {
+  if (!html || !siteUrl) return [];
+  const links = [];
+  const base = siteUrl.replace(/\/$/, '');
+  const regex = /<a\s+[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\/a>/gi;
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    const href = match[1];
+    const text = stripHtml(match[2]).trim();
+    if (href.startsWith(base) || href.startsWith('/') || href.startsWith('./')) {
+      links.push({
+        text: text || '[no anchor text]',
+        href: href.startsWith('/') ? `${base}${href}` : href
+      });
+    }
+  }
+  return links;
+}
+
+/**
+ * Truncate content to maxChars with informative suffix.
+ * @param {string} text
+ * @param {number} maxChars  0 = no limit
+ * @returns {string}
+ */
+export function truncateContent(text, maxChars = DEFAULT_MAX_CHARS) {
+  if (!maxChars || maxChars === 0 || !text || text.length <= maxChars) {
+    return text || '';
+  }
+  const truncated = text.substring(0, maxChars).replace(/\s+\S*$/, '');
+  const remaining = text.length - truncated.length;
+  return `${truncated}\n\n[truncated: ${remaining} chars remaining]`;
+}
+
+/**
+ * Filter post fields based on requested fields array.
+ * @param {object} post
+ * @param {string[]} fields
+ * @returns {object}
+ */
+export function summarizePost(post, fields) {
+  if (!fields || fields.length === 0) return post;
+  const allowed = new Set(fields);
+  const result = {};
+  for (const key of allowed) {
+    if (key in post) result[key] = post[key];
+  }
+  return result;
+}
+
+/**
+ * Apply content_format transformation to a post object.
+ * @param {object} post  Post with .content field
+ * @param {string} contentFormat  'html' | 'text' | 'links_only'
+ * @param {string} siteUrl  Site base URL
+ * @param {number} maxChars  Truncation limit (0 = unlimited)
+ * @returns {object}
+ */
+export function applyContentFormat(post, contentFormat, siteUrl, maxChars = DEFAULT_MAX_CHARS) {
+  if (!post || !post.content) return post;
+  const processed = { ...post };
+  switch (contentFormat) {
+    case 'text':
+      processed.content = truncateContent(stripHtml(post.content), maxChars);
+      processed._content_format = 'text';
+      break;
+    case 'links_only':
+      processed.content = null;
+      processed.internal_links = extractLinksOnly(post.content, siteUrl);
+      processed._content_format = 'links_only';
+      break;
+    case 'html':
+    default:
+      processed.content = truncateContent(post.content, maxChars);
+      processed._content_format = 'html';
+      break;
+  }
+  return processed;
+}

package/src/woocommerceClient.js

@@ -0,0 +1,88 @@
+/**
+ * WooCommerce REST API v3 client for WordPress MCP Server.
+ *
+ * Auth: Basic Auth with WC_CONSUMER_KEY + WC_CONSUMER_SECRET
+ * Base URL: WP_API_URL + /wp-json/wc/v3/
+ * Retry + timeout identical to the WordPress client in index.js
+ */
+
+import fetch from 'node-fetch';
+
+const MAX_RETRIES = parseInt(process.env.WP_MCP_MAX_RETRIES || '3', 10);
+const TIMEOUT_MS = parseInt(process.env.WP_MCP_TIMEOUT || '30000', 10);
+const RETRY_BASE_DELAY_MS = 1000;
+const VERBOSE = process.env.WP_MCP_VERBOSE === 'true';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+/**
+ * Check that WooCommerce credentials are configured.
+ * @returns {{ key: string, secret: string }}
+ * @throws {Error} if credentials are missing
+ */
+export function getWcCredentials() {
+  const key = process.env.WC_CONSUMER_KEY || '';
+  const secret = process.env.WC_CONSUMER_SECRET || '';
+  if (!key || !secret) {
+    throw new Error('WooCommerce credentials not configured (WC_CONSUMER_KEY, WC_CONSUMER_SECRET)');
+  }
+  return { key, secret };
+}
+
+/**
+ * Make an authenticated call to WooCommerce REST API v3.
+ *
+ * @param {string} endpoint  - Path after /wc/v3/, e.g. "/products"
+ * @param {object} options
+ * @param {string} options.method  - HTTP method (default GET)
+ * @param {string} options.body    - JSON body for POST/PUT
+ * @param {string} baseUrl         - WordPress base URL
+ * @returns {Promise<object>}
+ */
+export async function wcApiCall(endpoint, options = {}, baseUrl) {
+  const { key, secret } = getWcCredentials();
+  const url = `${baseUrl}/wp-json/wc/v3${endpoint}`;
+  const method = options.method || 'GET';
+  const auth = Buffer.from(`${key}:${secret}`).toString('base64');
+  const headers = {
+    'Authorization': `Basic ${auth}`,
+    'Content-Type': 'application/json',
+    'User-Agent': 'WordPress-MCP-Server/WooCommerce',
+  };
+
+  let lastError;
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    const controller = new AbortController();
+    const tid = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+      if (VERBOSE) console.error(`[DEBUG] WC ${method} ${endpoint} (${attempt}/${MAX_RETRIES})`);
+      const t0 = Date.now();
+      const fetchOpts = { method, headers, signal: controller.signal };
+      if (options.body) fetchOpts.body = options.body;
+      const response = await fetch(url, fetchOpts);
+      clearTimeout(tid);
+      if (VERBOSE) console.error(`[DEBUG] WC ${response.status} in ${Date.now() - t0}ms`);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        const sc = response.status;
+        if (sc >= 400 && sc < 500 && sc !== 429) {
+          const hints = { 400: 'Bad Request', 401: 'Unauthorized', 403: 'Forbidden', 404: 'Not Found', 405: 'Method Not Allowed' };
+          throw new Error(`WC API ${sc}: ${hints[sc] || ''}\n${errorText}`);
+        }
+        lastError = new Error(`WC API ${sc}: ${errorText}`);
+        if (sc === 429) { await sleep(parseInt(response.headers.get('retry-after') || '5', 10) * 1000); continue; }
+        if (attempt < MAX_RETRIES) { await sleep(RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1)); continue; }
+        throw lastError;
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(tid);
+      if (error.name === 'AbortError') lastError = new Error(`WC timeout ${TIMEOUT_MS}ms`);
+      else if (error.message.includes('WC API 4')) throw error;
+      else lastError = error;
+      if (attempt < MAX_RETRIES) await sleep(RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1));
+    }
+  }
+  throw lastError || new Error(`WC call failed after ${MAX_RETRIES} attempts`);
+}