wpfleet 1.0.0

package/src/commands/ai-optimize.js

@@ -0,0 +1,242 @@
+import chalk from 'chalk';
+import axios from 'axios';
+import { getSite, getSites } from '../config.js';
+import { getAiConfig, aiComplete } from '../ai/client.js';
+import { metaOptimizationPrompt, batchScoringPrompt } from '../ai/seo-prompts.js';
+import { makeTable } from '../utils/display.js';
+
+function makeWpClient(site) {
+  const baseURL = site.url.replace(/\/$/, '') + '/wp-json';
+  const token = Buffer.from(`${site.wp_user}:${site.wp_app_password}`).toString('base64');
+  return axios.create({
+    baseURL,
+    timeout: 15000,
+    validateStatus: () => true,
+    headers: { Authorization: `Basic ${token}` },
+  });
+}
+
+function stripHtml(html) {
+  return (html || '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function wordCount(html) {
+  return stripHtml(html).split(/\s+/).filter(Boolean).length;
+}
+
+function parseJson(text) {
+  // Strip markdown code fences if present
+  let cleaned = text.replace(/```(?:json)?\s*/g, '').replace(/```\s*/g, '').trim();
+  // Extract JSON from potential surrounding text
+  const match = cleaned.match(/(\[[\s\S]*\]|\{[\s\S]*\})/);
+  if (!match) throw new Error('No JSON found in AI response');
+  return JSON.parse(match[1]);
+}
+
+function scoreColor(score) {
+  if (score >= 70) return chalk.green(String(score));
+  if (score >= 40) return chalk.yellow(String(score));
+  return chalk.red(String(score));
+}
+
+function priorityColor(priority) {
+  if (priority === 'high') return chalk.red(priority);
+  if (priority === 'medium') return chalk.yellow(priority);
+  return chalk.green(priority);
+}
+
+async function fetchPosts(client, perPage = 50) {
+  const res = await client.get('/wp/v2/posts', {
+    params: { per_page: perPage, orderby: 'date', order: 'desc', _fields: 'id,title,link,excerpt,content,slug' },
+  });
+  if (res.status !== 200 || !Array.isArray(res.data)) {
+    throw new Error(`Failed to fetch posts: HTTP ${res.status}`);
+  }
+  return res.data;
+}
+
+async function optimizeSinglePost(site, postId, apply) {
+  const client = makeWpClient(site);
+  const res = await client.get(`/wp/v2/posts/${postId}`, {
+    params: { _fields: 'id,title,link,excerpt,content,slug' },
+  });
+
+  if (res.status !== 200 || !res.data) {
+    throw new Error(`Post ${postId} not found: HTTP ${res.status}`);
+  }
+
+  const post = res.data;
+  const title = post.title?.rendered || '';
+  const content = post.content?.rendered || '';
+  const currentMeta = stripHtml(post.excerpt?.rendered || '');
+  const url = post.link || '';
+
+  console.log(chalk.bold(`\nAnalyzing: "${title}"`));
+  console.log(chalk.dim(`URL: ${url}`));
+
+  const { system, user } = metaOptimizationPrompt({ title, content, currentMeta, url });
+
+  let raw;
+  try {
+    raw = await aiComplete({ systemPrompt: system, userPrompt: user, maxTokens: 600 });
+  } catch (err) {
+    throw new Error(`AI error: ${err.message}`);
+  }
+
+  let analysis;
+  try {
+    analysis = parseJson(raw);
+  } catch {
+    throw new Error('Could not parse AI response as JSON');
+  }
+
+  console.log(`\nSEO Score: ${scoreColor(analysis.score)}/100`);
+
+  if (analysis.issues && analysis.issues.length > 0) {
+    console.log(chalk.bold('\nIssues:'));
+    analysis.issues.forEach(issue => console.log(`  • ${issue}`));
+  }
+
+  console.log(chalk.bold('\nOptimized Title:'));
+  console.log(`  ${analysis.optimized_title}`);
+
+  console.log(chalk.bold('\nOptimized Meta Description:'));
+  console.log(`  ${analysis.optimized_meta}`);
+
+  if (analysis.recommendations && analysis.recommendations.length > 0) {
+    console.log(chalk.bold('\nRecommendations:'));
+    analysis.recommendations.forEach(rec => console.log(`  • ${rec}`));
+  }
+
+  if (apply) {
+    console.log(chalk.dim('\nApplying changes...'));
+    const updateRes = await client.post(`/wp/v2/posts/${postId}`, {
+      title: analysis.optimized_title,
+      excerpt: analysis.optimized_meta,
+    });
+
+    if (updateRes.status !== 200) {
+      throw new Error(`Update failed ${updateRes.status}: ${JSON.stringify(updateRes.data?.message || updateRes.data)}`);
+    }
+    console.log(chalk.green('Applied: title and meta description updated'));
+  } else {
+    console.log(chalk.dim('\nRun with --apply to push these changes to WordPress'));
+  }
+}
+
+async function scoreAllPosts(site) {
+  const client = makeWpClient(site);
+  console.log(chalk.dim(`Fetching posts from ${site.name}...`));
+
+  let posts;
+  try {
+    posts = await fetchPosts(client, 50);
+  } catch (err) {
+    throw new Error(`Could not fetch posts: ${err.message}`);
+  }
+
+  if (posts.length === 0) {
+    console.log(chalk.yellow('No posts found'));
+    return;
+  }
+
+  const postData = posts.map(p => ({
+    id: p.id,
+    title: p.title?.rendered || '',
+    wordCount: wordCount(p.content?.rendered || ''),
+    hasMeta: !!stripHtml(p.excerpt?.rendered || ''),
+    link: p.link || '',
+  }));
+
+  // Batch scoring in chunks of 15 to avoid truncation
+  const BATCH_SIZE = 15;
+  let scores = [];
+  const totalBatches = Math.ceil(postData.length / BATCH_SIZE);
+  console.log(chalk.dim(`Scoring ${postData.length} posts with AI (${totalBatches} batch${totalBatches > 1 ? 'es' : ''})...`));
+
+  for (let i = 0; i < postData.length; i += BATCH_SIZE) {
+    const batch = postData.slice(i, i + BATCH_SIZE);
+    const batchNum = Math.floor(i / BATCH_SIZE) + 1;
+    if (totalBatches > 1) console.log(chalk.dim(`  Batch ${batchNum}/${totalBatches}...`));
+    
+    const { system, user } = batchScoringPrompt({ posts: batch });
+
+    let raw;
+    try {
+      raw = await aiComplete({ systemPrompt: system, userPrompt: user, maxTokens: 800 });
+    } catch (err) {
+      console.error(chalk.yellow(`  Batch ${batchNum} AI error: ${err.message}`));
+      continue;
+    }
+
+    try {
+      const batchScores = parseJson(raw);
+      if (Array.isArray(batchScores)) scores.push(...batchScores);
+    } catch {
+      console.error(chalk.yellow(`  Batch ${batchNum}: could not parse AI response`));
+    }
+  }
+
+  if (scores.length === 0) {
+    throw new Error('AI scoring failed for all batches');
+  }
+
+  // Build lookup map
+  const scoreMap = {};
+  for (const s of scores) scoreMap[s.id] = s;
+
+  // Sort by score ascending (worst first = fix first)
+  const sorted = postData
+    .map(p => ({ ...p, ...(scoreMap[p.id] || { score: 50, priority: 'medium', top_issue: '?' }) }))
+    .sort((a, b) => a.score - b.score);
+
+  const table = makeTable(['ID', 'Title', 'Score', 'Priority', 'Top Issue'], [6, 35, 7, 8, 30]);
+  for (const p of sorted) {
+    const shortTitle = p.title.length > 33 ? p.title.slice(0, 32) + '…' : p.title;
+    const shortIssue = (p.top_issue || '').slice(0, 28);
+    table.push([String(p.id), shortTitle, scoreColor(p.score), priorityColor(p.priority), shortIssue]);
+  }
+
+  console.log(`\n${chalk.bold(`SEO Optimization Report — ${site.name}`)}`);
+  console.log(table.toString());
+  console.log(chalk.dim(`\nRun: wpfleet ai-optimize --site ${site.name} --post <id> [--apply]`));
+}
+
+export async function aiOptimizeCommand(options) {
+  if (!options.site) {
+    console.error(chalk.red('Error: --site <name> is required'));
+    process.exit(1);
+  }
+
+  if (!getAiConfig()) {
+    console.error(chalk.red('No AI API key configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY'));
+    console.error(chalk.dim('Or add ai.api_key to wpfleet.yml'));
+    process.exit(1);
+  }
+
+  const site = getSite(options.site);
+  if (!site) {
+    console.error(chalk.red(`Site not found: ${options.site}`));
+    process.exit(1);
+  }
+
+  if (!site.wp_user || !site.wp_app_password) {
+    console.error(chalk.red(`Site "${site.name}" requires wp_user and wp_app_password`));
+    process.exit(1);
+  }
+
+  try {
+    if (options.post) {
+      await optimizeSinglePost(site, options.post, options.apply);
+    } else {
+      if (options.apply) {
+        console.error(chalk.red('--apply requires --post <id>'));
+        process.exit(1);
+      }
+      await scoreAllPosts(site);
+    }
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/ai-write.js

@@ -0,0 +1,119 @@
+import fs from 'fs';
+import chalk from 'chalk';
+import axios from 'axios';
+import { marked } from 'marked';
+import matter from 'gray-matter';
+import { getSite } from '../config.js';
+import { getAiConfig, aiComplete } from '../ai/client.js';
+import { articleGenerationPrompt } from '../ai/seo-prompts.js';
+
+function makeWpClient(site) {
+  const baseURL = site.url.replace(/\/$/, '') + '/wp-json';
+  const token = Buffer.from(`${site.wp_user}:${site.wp_app_password}`).toString('base64');
+  return axios.create({
+    baseURL,
+    timeout: 15000,
+    validateStatus: () => true,
+    headers: { Authorization: `Basic ${token}` },
+  });
+}
+
+async function getSiteContext(site) {
+  try {
+    const client = makeWpClient(site);
+    const res = await client.get('/wp/v2/posts', {
+      params: { per_page: 15, orderby: 'date', order: 'desc', _fields: 'title,link,slug' },
+    });
+    if (res.status !== 200 || !Array.isArray(res.data)) return '';
+    return res.data.map(p => `- ${p.title.rendered}: ${p.link}`).join('\n');
+  } catch {
+    return '';
+  }
+}
+
+export async function aiWriteCommand(options) {
+  if (!options.topic) {
+    console.error(chalk.red('Error: --topic <topic> is required'));
+    process.exit(1);
+  }
+  if (!options.site) {
+    console.error(chalk.red('Error: --site <name> is required'));
+    process.exit(1);
+  }
+
+  if (!getAiConfig()) {
+    console.error(chalk.red('No AI API key configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY'));
+    console.error(chalk.dim('Or add ai.api_key to wpfleet.yml'));
+    process.exit(1);
+  }
+
+  const site = getSite(options.site);
+  if (!site) {
+    console.error(chalk.red(`Site not found: ${options.site}`));
+    process.exit(1);
+  }
+
+  const words = parseInt(options.words || '1500', 10);
+  const lang = options.lang || 'en';
+  const keywords = options.keywords ? options.keywords.split(',').map(k => k.trim()).filter(Boolean) : [];
+
+  console.log(chalk.bold(`Generating: "${options.topic}"`));
+  console.log(chalk.dim(`${words} words | lang: ${lang} | site: ${site.name}`));
+
+  console.log(chalk.dim('Fetching site context...'));
+  const siteContext = await getSiteContext(site);
+
+  const { system, user } = articleGenerationPrompt({ topic: options.topic, keywords, words, lang, siteContext });
+  const maxTokens = Math.min(Math.ceil(words * 1.8) + 600, 8000);
+
+  let markdown;
+  try {
+    markdown = await aiComplete({ systemPrompt: system, userPrompt: user, maxTokens });
+  } catch (err) {
+    console.error(chalk.red(`AI error: ${err.message}`));
+    process.exit(1);
+  }
+
+  // Strip code fences if the model wrapped the output
+  markdown = markdown.replace(/^```(?:markdown)?\n?/m, '').replace(/\n?```\s*$/m, '').trim();
+
+  const { data: fm, content } = matter(markdown);
+  const title = fm.title || options.topic;
+
+  console.log(chalk.green(`\nTitle: ${title}`));
+  if (fm.meta_description) console.log(chalk.dim(`Meta: ${fm.meta_description}`));
+
+  if (options.draft) {
+    // Save markdown locally; don't publish
+    const slug = fm.slug || options.topic.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+    const fileName = `${slug}.md`;
+    fs.writeFileSync(fileName, markdown, 'utf8');
+    console.log(chalk.cyan(`Draft saved: ${fileName}`));
+    return;
+  }
+
+  // Publish to WordPress
+  if (!site.wp_user || !site.wp_app_password) {
+    console.error(chalk.red(`Site "${site.name}" requires wp_user and wp_app_password`));
+    console.error(chalk.dim('Use --draft to save the article locally instead'));
+    process.exit(1);
+  }
+
+  console.log(chalk.dim(`Publishing to ${site.name}...`));
+
+  const html = marked(content) + '\n<!-- AI-generated content -->';
+  const client = makeWpClient(site);
+  const res = await client.post('/wp/v2/posts', {
+    title,
+    content: html,
+    status: 'publish',
+    excerpt: fm.meta_description || '',
+  });
+
+  if (res.status !== 201) {
+    console.error(chalk.red(`Publish failed ${res.status}: ${JSON.stringify(res.data?.message || res.data)}`));
+    process.exit(1);
+  }
+
+  console.log(chalk.green(`Published: ${res.data.link}`));
+}

package/src/commands/health.js

@@ -0,0 +1,100 @@
+import { URL } from 'url';
+import chalk from 'chalk';
+import { getSites, getSite } from '../config.js';
+import { getResponseTime, getSslExpiry } from '../utils/http.js';
+import { getWpInfo, getPlugins } from '../utils/wp-api.js';
+import { makeTable, colorByResponseTime, na } from '../utils/display.js';
+
+async function fetchHealth(site) {
+  const { hostname } = new URL(site.url);
+  const [timing, sslExpiry, wpInfo, plugins] = await Promise.all([
+    getResponseTime(site.url),
+    getSslExpiry(hostname),
+    getWpInfo(site),
+    getPlugins(site),
+  ]);
+
+  const wpVersion = wpInfo ? (wpInfo.generator ? wpInfo.generator.replace('https://wordpress.org/?v=', '') : (wpInfo.description ? null : null)) : null;
+  // WP REST API root has a 'generator' field like "https://wordpress.org/?v=6.4.2"
+  let version = null;
+  if (wpInfo && wpInfo.generator) {
+    const match = wpInfo.generator.match(/v=([\d.]+)/);
+    if (match) version = match[1];
+  }
+
+  let daysUntilSslExpiry = null;
+  if (sslExpiry) {
+    daysUntilSslExpiry = Math.floor((sslExpiry - Date.now()) / (1000 * 60 * 60 * 24));
+  }
+
+  let pluginCount = null;
+  let pluginUpdates = null;
+  if (plugins) {
+    pluginCount = plugins.length;
+    pluginUpdates = plugins.filter(p => p.update && p.update !== 'none').length;
+  }
+
+  return {
+    responseTime: timing.ms,
+    daysUntilSslExpiry,
+    wpVersion: version,
+    pluginCount,
+    pluginUpdates,
+  };
+}
+
+function colorSsl(days) {
+  if (days === null) return na();
+  const str = `${days}d`;
+  if (days <= 14) return chalk.red(str);
+  if (days <= 30) return chalk.yellow(str);
+  return chalk.green(str);
+}
+
+function colorPluginUpdates(count) {
+  if (count === null) return na();
+  if (count > 0) return chalk.yellow(String(count));
+  return chalk.green('0');
+}
+
+function renderRow(site, h) {
+  return [
+    site.name,
+    colorByResponseTime(h.responseTime),
+    colorSsl(h.daysUntilSslExpiry),
+    h.wpVersion ? chalk.cyan(h.wpVersion) : na(),
+    h.pluginCount !== null ? String(h.pluginCount) : na(),
+    colorPluginUpdates(h.pluginUpdates),
+  ];
+}
+
+export async function healthCommand(siteName) {
+  const table = makeTable(
+    ['Name', 'Response', 'SSL Expiry', 'WP Version', 'Plugins', 'Updates'],
+    [18, 12, 12, 12, 10, 10]
+  );
+
+  if (siteName) {
+    const site = getSite(siteName);
+    if (!site) {
+      console.error(chalk.red(`Site not found: ${siteName}`));
+      process.exit(1);
+    }
+    console.log(chalk.dim(`Checking health for ${site.name}...`));
+    const h = await fetchHealth(site);
+    table.push(renderRow(site, h));
+  } else {
+    const sites = getSites();
+    if (sites.length === 0) {
+      console.log(chalk.yellow('No sites configured. Run: wpfleet sites add'));
+      return;
+    }
+    console.log(chalk.dim('Checking health for all sites...'));
+    const allHealth = await Promise.all(sites.map(fetchHealth));
+    for (let i = 0; i < sites.length; i++) {
+      table.push(renderRow(sites[i], allHealth[i]));
+    }
+  }
+
+  console.log(table.toString());
+}

package/src/commands/interlink.js

@@ -0,0 +1,208 @@
+import chalk from 'chalk';
+import axios from 'axios';
+import { getSite, getSites } from '../config.js';
+import { makeTable } from '../utils/display.js';
+
+function makeClient(site) {
+  const baseURL = site.url.replace(/\/$/, '') + '/wp-json';
+  const config = { baseURL, timeout: 15000, validateStatus: () => true };
+  if (site.wp_user && site.wp_app_password) {
+    const token = Buffer.from(`${site.wp_user}:${site.wp_app_password}`).toString('base64');
+    config.headers = { Authorization: `Basic ${token}` };
+  }
+  return axios.create(config);
+}
+
+async function fetchAllPosts(site) {
+  const client = makeClient(site);
+  let page = 1;
+  let posts = [];
+  while (true) {
+    const res = await client.get('/wp/v2/posts', {
+      params: { per_page: 100, page, _fields: 'id,title,link,content,slug' },
+    });
+    if (res.status !== 200 || !Array.isArray(res.data) || res.data.length === 0) break;
+    posts = posts.concat(res.data);
+    const totalPages = parseInt(res.headers['x-wp-totalpages'] || '1', 10);
+    if (page >= totalPages) break;
+    page++;
+  }
+  return posts;
+}
+
+const STOP_WORDS = new Set([
+  'that', 'this', 'with', 'have', 'from', 'they', 'will', 'been', 'were',
+  'said', 'each', 'which', 'their', 'into', 'there', 'your', 'what', 'more',
+  'also', 'then', 'than', 'when', 'where', 'some', 'these', 'those', 'about',
+  'most', 'other', 'like', 'just', 'time', 'very', 'only', 'even', 'such',
+]);
+
+export function extractKeywords(text) {
+  const clean = (text || '').replace(/<[^>]+>/g, ' ').toLowerCase();
+  const words = clean.match(/\b[a-z]{4,}\b/g) || [];
+  const freq = {};
+  for (const w of words) {
+    if (!STOP_WORDS.has(w)) freq[w] = (freq[w] || 0) + 1;
+  }
+  return freq;
+}
+
+export function relevanceScore(freqA, freqB) {
+  const totalA = Object.values(freqA).reduce((a, b) => a + b, 0);
+  const totalB = Object.values(freqB).reduce((a, b) => a + b, 0);
+  if (!totalA || !totalB) return 0;
+  const keysB = new Set(Object.keys(freqB));
+  let shared = 0;
+  for (const k of Object.keys(freqA)) {
+    if (keysB.has(k)) shared += Math.min(freqA[k], freqB[k]);
+  }
+  return Math.round((shared / Math.sqrt(totalA * totalB)) * 100);
+}
+
+function bestAnchor(sourceFreq, targetFreq) {
+  const shared = Object.keys(targetFreq)
+    .filter(k => sourceFreq[k])
+    .sort((a, b) => targetFreq[b] - targetFreq[a]);
+  return shared[0] || 'related article';
+}
+
+function hasLinkTo(content, targetUrl) {
+  return (content || '').includes(targetUrl.replace(/\/$/, ''));
+}
+
+function scoreColor(score) {
+  if (score >= 70) return chalk.green(String(score));
+  if (score >= 50) return chalk.yellow(String(score));
+  return chalk.gray(String(score));
+}
+
+export async function interlinkCommand(options) {
+  const siteName = options.site;
+  const site = siteName ? getSite(siteName) : getSites()[0];
+  if (!site) {
+    console.error(chalk.red(siteName ? `Site not found: ${siteName}` : 'No sites configured'));
+    process.exit(1);
+  }
+
+  const minRelevance = parseInt(options.minRelevance || '50', 10);
+  console.log(chalk.dim(`Fetching posts from ${site.name}...`));
+  const posts = await fetchAllPosts(site);
+
+  if (posts.length === 0) {
+    console.log(chalk.yellow('No posts found'));
+    return;
+  }
+
+  console.log(chalk.dim(`Analyzing ${posts.length} posts...`));
+
+  const postData = posts.map(p => ({
+    id: p.id,
+    title: p.title?.rendered || p.slug,
+    link: p.link,
+    content: p.content?.rendered || '',
+    keywords: extractKeywords((p.title?.rendered || '') + ' ' + (p.content?.rendered || '')),
+  }));
+
+  const suggestions = [];
+  for (let i = 0; i < postData.length; i++) {
+    for (let j = 0; j < postData.length; j++) {
+      if (i === j) continue;
+      const score = relevanceScore(postData[i].keywords, postData[j].keywords);
+      if (score < minRelevance) continue;
+      if (hasLinkTo(postData[i].content, postData[j].link)) continue;
+      suggestions.push({
+        sourceId: postData[i].id,
+        sourceTitle: postData[i].title,
+        sourceContent: postData[i].content,
+        targetTitle: postData[j].title,
+        targetLink: postData[j].link,
+        anchor: bestAnchor(postData[i].keywords, postData[j].keywords),
+        score,
+      });
+    }
+  }
+
+  suggestions.sort((a, b) => b.score - a.score);
+
+  if (suggestions.length === 0) {
+    console.log(chalk.yellow(`No suggestions found with relevance >= ${minRelevance}`));
+    return;
+  }
+
+  if (options.auto) {
+    console.log(chalk.dim(`Applying top suggestions automatically...`));
+    const client = makeClient(site);
+    const applied = suggestions.slice(0, 20);
+    for (const s of applied) {
+      const seeAlso = `\n<p>See also: <a href="${s.targetLink}">${s.anchor}</a></p>`;
+      await client.post(`/wp/v2/posts/${s.sourceId}`, { content: s.sourceContent + seeAlso });
+      console.log(chalk.green(`  Linked "${s.sourceTitle}" → "${s.targetTitle}"`));
+    }
+    return;
+  }
+
+  // Detect orphan posts (no suggestions pointing TO them)
+  const linkedTargets = new Set(suggestions.map(s => s.targetTitle));
+  const orphans = postData.filter(p => !linkedTargets.has(p.title));
+  if (orphans.length > 0) {
+    console.log(chalk.yellow(`\nOrphan posts (no incoming internal link suggestions): ${orphans.length}`));
+    for (const o of orphans.slice(0, 5)) {
+      console.log(chalk.dim(`  - ${o.title}`));
+    }
+  }
+
+  console.log('');
+  const table = makeTable(['Source Post', 'Target Post', 'Anchor Text', 'Score'], [32, 32, 22, 8]);
+  for (const s of suggestions.slice(0, 30)) {
+    table.push([
+      s.sourceTitle.slice(0, 30),
+      s.targetTitle.slice(0, 30),
+      s.anchor.slice(0, 20),
+      scoreColor(s.score),
+    ]);
+  }
+  console.log(table.toString());
+}
+
+export async function crosslinkCommand(siteNameA, siteNameB) {
+  const siteA = getSite(siteNameA);
+  const siteB = getSite(siteNameB);
+  if (!siteA) { console.error(chalk.red(`Site not found: ${siteNameA}`)); process.exit(1); }
+  if (!siteB) { console.error(chalk.red(`Site not found: ${siteNameB}`)); process.exit(1); }
+
+  console.log(chalk.dim(`Fetching posts from ${siteA.name} and ${siteB.name}...`));
+  const [postsA, postsB] = await Promise.all([fetchAllPosts(siteA), fetchAllPosts(siteB)]);
+
+  const dataA = postsA.map(p => ({
+    title: p.title?.rendered || p.slug,
+    link: p.link,
+    keywords: extractKeywords((p.title?.rendered || '') + ' ' + (p.content?.rendered || '')),
+  }));
+
+  const dataB = postsB.map(p => ({
+    title: p.title?.rendered || p.slug,
+    link: p.link,
+    keywords: extractKeywords((p.title?.rendered || '') + ' ' + (p.content?.rendered || '')),
+  }));
+
+  const pairs = [];
+  for (const a of dataA) {
+    for (const b of dataB) {
+      const score = relevanceScore(a.keywords, b.keywords);
+      if (score >= 30) pairs.push({ titleA: a.title, titleB: b.title, score });
+    }
+  }
+
+  pairs.sort((a, b) => b.score - a.score);
+
+  if (pairs.length === 0) {
+    console.log(chalk.yellow('No cross-linking opportunities found'));
+    return;
+  }
+
+  const table = makeTable([`${siteA.name} Post`, `${siteB.name} Post`, 'Relevance'], [35, 35, 12]);
+  for (const p of pairs.slice(0, 20)) {
+    table.push([p.titleA.slice(0, 33), p.titleB.slice(0, 33), scoreColor(p.score)]);
+  }
+  console.log(table.toString());
+}