@adsim/wordpress-mcp-server 4.6.0 → 5.3.1

package/tests/unit/tools/editorialIntelligence.test.js

@@ -0,0 +1,817 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall, _testSetTarget } from '../../../index.js';
+import { makeRequest, mockSuccess, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+let consoleSpy;
+
+beforeEach(() => {
+  fetch.mockReset();
+  consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  _testSetTarget('site1', { url: 'https://example.com', auth: 'Basic dGVzdDp0ZXN0' });
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+});
+
+// Helper: create mock post — title, content, excerpt are extracted
+// so that ...rest doesn't overwrite the { rendered: ... } wrappers.
+function mockPost(overrides = {}) {
+  const { title, content, excerpt, ...rest } = overrides;
+  return {
+    id: 1,
+    title: { rendered: title || 'Test Post' },
+    content: { rendered: content || '<p>Some default content here for testing purposes with enough words to be meaningful in our analysis pipeline.</p>' },
+    excerpt: { rendered: excerpt || '<p>Test excerpt</p>' },
+    slug: 'test-post',
+    link: 'https://example.com/test-post/',
+    date: '2025-06-15T10:00:00',
+    modified: '2025-06-15T10:00:00',
+    status: 'publish',
+    author: 1,
+    categories: [1],
+    tags: [],
+    ...rest
+  };
+}
+
+// =========================================================================
+// wp_suggest_content_updates
+// =========================================================================
+
+describe('wp_suggest_content_updates', () => {
+  it('identifies stale posts older than threshold', async () => {
+    const oldDate = '2024-01-15T10:00:00';
+    fetch.mockImplementation(() => Promise.resolve({
+      ok: true, status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => Promise.resolve([
+        mockPost({ id: 1, title: 'Old Post', modified: oldDate, date: oldDate, content: '<p>' + 'word '.repeat(200) + '</p>' })
+      ]),
+      text: () => Promise.resolve('[]')
+    }));
+
+    const res = await call('wp_suggest_content_updates', { months: 6 });
+    const data = parseResult(res);
+    expect(data.suggestions.length).toBeGreaterThan(0);
+    expect(data.suggestions[0].days_since_update).toBeGreaterThan(180);
+  });
+
+  it('detects outdated year references in content', async () => {
+    const oldDate = '2024-03-01T10:00:00';
+    fetch.mockImplementation(() => Promise.resolve({
+      ok: true, status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => Promise.resolve([
+        mockPost({ id: 2, title: 'Guide 2022', modified: oldDate, date: oldDate, content: '<p>En 2022, les meilleures pratiques étaient différentes. Mise à jour en 2023 pour refléter les changements. ' + 'word '.repeat(150) + '</p>' })
+      ]),
+      text: () => Promise.resolve('[]')
+    }));
+
+    const res = await call('wp_suggest_content_updates', { months: 3 });
+    const data = parseResult(res);
+    expect(data.suggestions.length).toBe(1);
+    const reasons = data.suggestions[0].reasons.join(' ');
+    expect(reasons).toMatch(/outdated date/i);
+  });
+
+  it('flags thin content with bonus priority', async () => {
+    const oldDate = '2024-02-01T10:00:00';
+    fetch.mockImplementation(() => Promise.resolve({
+      ok: true, status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => Promise.resolve([
+        mockPost({ id: 3, modified: oldDate, date: oldDate, content: '<p>' + 'word '.repeat(150) + '</p>' }),
+        mockPost({ id: 4, modified: oldDate, date: oldDate, content: '<p>' + 'word '.repeat(500) + '</p>' })
+      ]),
+      text: () => Promise.resolve('[]')
+    }));
+
+    const res = await call('wp_suggest_content_updates', { months: 3 });
+    const data = parseResult(res);
+    const thin = data.suggestions.find(s => s.post_id === 3);
+    const thick = data.suggestions.find(s => s.post_id === 4);
+    expect(thin).toBeDefined();
+    expect(thick).toBeDefined();
+    // Thin content should have higher priority (includes thin bonus)
+    expect(thin.reasons.join(' ')).toMatch(/thin content/i);
+  });
+
+  it('excludes posts below min_word_count', async () => {
+    const oldDate = '2024-01-01T10:00:00';
+    fetch.mockImplementation(() => Promise.resolve({
+      ok: true, status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => Promise.resolve([
+        mockPost({ id: 5, modified: oldDate, date: oldDate, content: '<p>Short</p>' })
+      ]),
+      text: () => Promise.resolve('[]')
+    }));
+
+    const res = await call('wp_suggest_content_updates', { months: 3, min_word_count: 100 });
+    const data = parseResult(res);
+    expect(data.suggestions).toHaveLength(0);
+  });
+
+  it('returns priority_score sorted descending', async () => {
+    const oldDate1 = '2023-01-01T10:00:00';
+    const oldDate2 = '2024-06-01T10:00:00';
+    fetch.mockImplementation(() => Promise.resolve({
+      ok: true, status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => Promise.resolve([
+        mockPost({ id: 10, modified: oldDate2, date: oldDate2, content: '<p>' + 'word '.repeat(200) + '</p>' }),
+        mockPost({ id: 11, modified: oldDate1, date: oldDate1, content: '<p>' + 'word '.repeat(200) + '</p>' })
+      ]),
+      text: () => Promise.resolve('[]')
+    }));
+
+    const res = await call('wp_suggest_content_updates', { months: 3 });
+    const data = parseResult(res);
+    expect(data.suggestions.length).toBe(2);
+    expect(data.suggestions[0].priority_score).toBeGreaterThanOrEqual(data.suggestions[1].priority_score);
+  });
+
+  it('handles multiple post_types', async () => {
+    let callCount = 0;
+    fetch.mockImplementation(() => {
+      callCount++;
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve([mockPost({ id: callCount, modified: '2024-01-01T10:00:00', date: '2024-01-01T10:00:00', content: '<p>' + 'word '.repeat(200) + '</p>' })]),
+        text: () => Promise.resolve('[]')
+      });
+    });
+
+    const res = await call('wp_suggest_content_updates', { months: 3, post_types: ['post', 'page'] });
+    const data = parseResult(res);
+    expect(data.total_analyzed).toBeGreaterThanOrEqual(2);
+  });
+});
+
+// =========================================================================
+// wp_audit_author_consistency
+// =========================================================================
+
+describe('wp_audit_author_consistency', () => {
+  function mockAuthorFlow(users, postsByAuthor) {
+    fetch.mockImplementation((url) => {
+      const u = typeof url === 'string' ? url : url.toString();
+      if (u.includes('/users')) {
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve(users),
+          text: () => Promise.resolve(JSON.stringify(users))
+        });
+      }
+      // Match author= parameter
+      const authorMatch = u.match(/author=(\d+)/);
+      const authorId = authorMatch ? parseInt(authorMatch[1]) : null;
+      const posts = postsByAuthor[authorId] || [];
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve(posts),
+        text: () => Promise.resolve(JSON.stringify(posts))
+      });
+    });
+  }
+
+  it('returns author profiles with stats', async () => {
+    mockAuthorFlow(
+      [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }],
+      {
+        1: Array.from({ length: 5 }, (_, i) => mockPost({ id: i + 1, author: 1, date: `2025-0${i + 1}-15T10:00:00`, content: '<p>' + 'word '.repeat(300) + '</p>' })),
+        2: Array.from({ length: 3 }, (_, i) => mockPost({ id: i + 10, author: 2, date: `2025-0${i + 1}-15T10:00:00`, content: '<p>' + 'word '.repeat(150) + '</p>' }))
+      }
+    );
+
+    const res = await call('wp_audit_author_consistency', { min_posts: 3 });
+    const data = parseResult(res);
+    expect(data.authors.length).toBe(2);
+    expect(data.authors[0].post_count).toBe(5);
+    expect(data.authors[0].avg_word_count).toBeGreaterThan(0);
+    expect(data.site_average.avg_word_count).toBeGreaterThan(0);
+  });
+
+  it('filters out authors below min_posts', async () => {
+    mockAuthorFlow(
+      [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }],
+      {
+        1: Array.from({ length: 5 }, (_, i) => mockPost({ id: i + 1, author: 1, content: '<p>' + 'word '.repeat(200) + '</p>' })),
+        2: [mockPost({ id: 10, author: 2, content: '<p>' + 'word '.repeat(200) + '</p>' })]
+      }
+    );
+
+    const res = await call('wp_audit_author_consistency', { min_posts: 3 });
+    const data = parseResult(res);
+    expect(data.authors.length).toBe(1);
+    expect(data.authors[0].name).toBe('Alice');
+  });
+
+  it('computes deviation from site average', async () => {
+    mockAuthorFlow(
+      [{ id: 1, name: 'Short Writer' }, { id: 2, name: 'Long Writer' }],
+      {
+        1: Array.from({ length: 4 }, (_, i) => mockPost({ id: i + 1, author: 1, date: `2025-0${i + 1}-15T10:00:00`, content: '<p>' + 'word '.repeat(100) + '</p>' })),
+        2: Array.from({ length: 4 }, (_, i) => mockPost({ id: i + 10, author: 2, date: `2025-0${i + 1}-15T10:00:00`, content: '<p>' + 'word '.repeat(500) + '</p>' }))
+      }
+    );
+
+    const res = await call('wp_audit_author_consistency', { min_posts: 3 });
+    const data = parseResult(res);
+    const short = data.authors.find(a => a.name === 'Short Writer');
+    const long = data.authors.find(a => a.name === 'Long Writer');
+    expect(short.deviation.word_count_vs_avg).toBeLessThan(0);
+    expect(long.deviation.word_count_vs_avg).toBeGreaterThan(0);
+  });
+
+  it('includes media usage stats', async () => {
+    mockAuthorFlow(
+      [{ id: 1, name: 'Visual Writer' }],
+      {
+        1: Array.from({ length: 3 }, (_, i) => mockPost({
+          id: i + 1, author: 1, date: `2025-0${i + 1}-15T10:00:00`,
+          content: '<p>Text content here with enough words for analysis.</p><img src="img1.jpg"><img src="img2.jpg"><p>' + 'word '.repeat(100) + '</p>'
+        }))
+      }
+    );
+
+    const res = await call('wp_audit_author_consistency', { min_posts: 3 });
+    const data = parseResult(res);
+    expect(data.authors[0].avg_media_per_post).toBeGreaterThanOrEqual(2);
+  });
+
+  it('calculates posts_per_month frequency', async () => {
+    mockAuthorFlow(
+      [{ id: 1, name: 'Prolific' }],
+      {
+        1: Array.from({ length: 6 }, (_, i) => mockPost({
+          id: i + 1, author: 1,
+          date: `2025-0${i + 1}-15T10:00:00`,
+          content: '<p>' + 'word '.repeat(200) + '</p>'
+        }))
+      }
+    );
+
+    const res = await call('wp_audit_author_consistency', { min_posts: 3 });
+    const data = parseResult(res);
+    expect(data.authors[0].posts_per_month).toBeGreaterThan(0);
+  });
+});
+
+// =========================================================================
+// wp_build_editorial_calendar
+// =========================================================================
+
+describe('wp_build_editorial_calendar', () => {
+  function mockCalendarFlow(publishedPosts, scheduledPosts = []) {
+    fetch.mockImplementation((url) => {
+      const u = typeof url === 'string' ? url : url.toString();
+      if (u.includes('status=future')) {
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve(scheduledPosts),
+          text: () => Promise.resolve(JSON.stringify(scheduledPosts))
+        });
+      }
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve(publishedPosts),
+        text: () => Promise.resolve(JSON.stringify(publishedPosts))
+      });
+    });
+  }
+
+  it('returns calendar with recommended posts per month', async () => {
+    const posts = Array.from({ length: 12 }, (_, i) => mockPost({
+      id: i + 1,
+      date: `2025-${String(i + 1).padStart(2, '0')}-15T10:00:00`,
+      categories: [1]
+    }));
+    mockCalendarFlow(posts);
+
+    const res = await call('wp_build_editorial_calendar', { months_ahead: 2 });
+    const data = parseResult(res);
+    expect(data.calendar.length).toBe(2);
+    expect(data.calendar[0].recommended_posts).toBeGreaterThanOrEqual(1);
+    expect(data.publishing_pattern.avg_posts_per_month).toBeGreaterThan(0);
+  });
+
+  it('detects best publishing days', async () => {
+    // All posts on Monday
+    const posts = Array.from({ length: 8 }, (_, i) => mockPost({
+      id: i + 1,
+      date: `2025-${String(i + 1).padStart(2, '0')}-06T10:00:00`, // Various Mondays/other days
+      categories: [1]
+    }));
+    mockCalendarFlow(posts);
+
+    const res = await call('wp_build_editorial_calendar');
+    const data = parseResult(res);
+    expect(data.publishing_pattern.best_days).toBeDefined();
+    expect(data.publishing_pattern.best_days.length).toBeLessThanOrEqual(3);
+  });
+
+  it('accounts for already scheduled posts', async () => {
+    const published = Array.from({ length: 6 }, (_, i) => mockPost({
+      id: i + 1,
+      date: `2025-${String(i + 1).padStart(2, '0')}-15T10:00:00`
+    }));
+
+    const now = new Date();
+    const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 15);
+    const futureDate = nextMonth.toISOString();
+
+    const scheduled = [mockPost({ id: 100, title: 'Future Post', date: futureDate, status: 'future' })];
+    mockCalendarFlow(published, scheduled);
+
+    const res = await call('wp_build_editorial_calendar', { months_ahead: 1 });
+    const data = parseResult(res);
+    expect(data.calendar[0].already_scheduled).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns top categories for topic suggestions', async () => {
+    const posts = Array.from({ length: 10 }, (_, i) => mockPost({
+      id: i + 1,
+      date: `2025-${String((i % 12) + 1).padStart(2, '0')}-15T10:00:00`,
+      categories: [i % 3 + 1]
+    }));
+    mockCalendarFlow(posts);
+
+    const res = await call('wp_build_editorial_calendar');
+    const data = parseResult(res);
+    expect(data.top_categories.length).toBeGreaterThan(0);
+    expect(data.top_categories[0].category_id).toBeDefined();
+  });
+
+  it('handles empty site gracefully', async () => {
+    mockCalendarFlow([]);
+
+    const res = await call('wp_build_editorial_calendar');
+    const data = parseResult(res);
+    expect(data.analysis_period.posts_analyzed).toBe(0);
+    expect(data.calendar.length).toBe(3); // default months_ahead
+  });
+});
+
+// =========================================================================
+// wp_find_pillar_content_gaps
+// =========================================================================
+
+describe('wp_find_pillar_content_gaps', () => {
+  function mockGapFlow(categories, tags, postsByCat = {}, postsByTag = {}) {
+    fetch.mockImplementation((url) => {
+      const u = typeof url === 'string' ? url : url.toString();
+      if (u.includes('/categories')) {
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve(categories),
+          text: () => Promise.resolve(JSON.stringify(categories))
+        });
+      }
+      if (u.includes('/tags')) {
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve(tags),
+          text: () => Promise.resolve(JSON.stringify(tags))
+        });
+      }
+      // Posts by category
+      const catMatch = u.match(/categories=(\d+)/);
+      if (catMatch) {
+        const posts = postsByCat[catMatch[1]] || [];
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve(posts),
+          text: () => Promise.resolve(JSON.stringify(posts))
+        });
+      }
+      // Posts by tag
+      const tagMatch = u.match(/tags=(\d+)/);
+      if (tagMatch) {
+        const posts = postsByTag[tagMatch[1]] || [];
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve(posts),
+          text: () => Promise.resolve(JSON.stringify(posts))
+        });
+      }
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve([]),
+        text: () => Promise.resolve('[]')
+      });
+    });
+  }
+
+  it('detects category gap when no pillar content exists', async () => {
+    const shortContent = '<p>' + 'word '.repeat(400) + '</p>'; // ~400 words
+    mockGapFlow(
+      [{ id: 1, name: 'SEO', slug: 'seo', count: 5, description: 'SEO tips' }],
+      [],
+      {
+        '1': Array.from({ length: 5 }, (_, i) => mockPost({ id: i + 1, content: shortContent, categories: [1] }))
+      }
+    );
+
+    const res = await call('wp_find_pillar_content_gaps', { min_cluster_size: 3 });
+    const data = parseResult(res);
+    expect(data.total_gaps).toBe(1);
+    expect(data.gaps[0].name).toBe('SEO');
+    expect(data.gaps[0].satellite_posts.length).toBe(5);
+    expect(data.gaps[0].recommendation).toContain('pillar');
+  });
+
+  it('skips category when pillar content exists', async () => {
+    const pillarContent = '<p>' + 'word '.repeat(2000) + '</p>';
+    const shortContent = '<p>' + 'word '.repeat(400) + '</p>';
+    mockGapFlow(
+      [{ id: 1, name: 'SEO', slug: 'seo', count: 4 }],
+      [],
+      {
+        '1': [
+          mockPost({ id: 1, content: pillarContent }), // pillar!
+          ...Array.from({ length: 3 }, (_, i) => mockPost({ id: i + 2, content: shortContent }))
+        ]
+      }
+    );
+
+    const res = await call('wp_find_pillar_content_gaps', { min_cluster_size: 3, min_word_count_pillar: 1500 });
+    const data = parseResult(res);
+    expect(data.total_gaps).toBe(0);
+  });
+
+  it('detects tag-based gaps', async () => {
+    const shortContent = '<p>' + 'word '.repeat(300) + '</p>';
+    mockGapFlow(
+      [],
+      [{ id: 10, name: 'React', slug: 'react', count: 4 }],
+      {},
+      {
+        '10': Array.from({ length: 4 }, (_, i) => mockPost({ id: i + 20, content: shortContent }))
+      }
+    );
+
+    const res = await call('wp_find_pillar_content_gaps', { min_cluster_size: 3 });
+    const data = parseResult(res);
+    expect(data.total_gaps).toBe(1);
+    expect(data.gaps[0].type).toBe('tag');
+    expect(data.gaps[0].name).toBe('React');
+  });
+
+  it('skips categories below min_cluster_size', async () => {
+    mockGapFlow(
+      [{ id: 1, name: 'Niche', slug: 'niche', count: 2 }],
+      []
+    );
+
+    const res = await call('wp_find_pillar_content_gaps', { min_cluster_size: 3 });
+    const data = parseResult(res);
+    expect(data.total_gaps).toBe(0);
+  });
+
+  it('sorts gaps by post_count descending', async () => {
+    const shortContent = '<p>' + 'word '.repeat(300) + '</p>';
+    mockGapFlow(
+      [
+        { id: 1, name: 'Small', slug: 'small', count: 3 },
+        { id: 2, name: 'Big', slug: 'big', count: 8 }
+      ],
+      [],
+      {
+        '1': Array.from({ length: 3 }, (_, i) => mockPost({ id: i + 1, content: shortContent })),
+        '2': Array.from({ length: 8 }, (_, i) => mockPost({ id: i + 10, content: shortContent }))
+      }
+    );
+
+    const res = await call('wp_find_pillar_content_gaps', { min_cluster_size: 3 });
+    const data = parseResult(res);
+    expect(data.gaps.length).toBe(2);
+    expect(data.gaps[0].name).toBe('Big');
+  });
+});
+
+// =========================================================================
+// wp_audit_internal_link_equity
+// =========================================================================
+
+describe('wp_audit_internal_link_equity', () => {
+  function mockLinkFlow(posts) {
+    fetch.mockImplementation((url) => {
+      const u = typeof url === 'string' ? url : url.toString();
+      // Return posts for any first-page /posts? call
+      if (u.includes('/posts') && u.includes('page=1')) {
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve(posts),
+          text: () => Promise.resolve(JSON.stringify(posts))
+        });
+      }
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve([]),
+        text: () => Promise.resolve('[]')
+      });
+    });
+  }
+
+  it('identifies orphan pages with zero inbound links', async () => {
+    mockLinkFlow([
+      mockPost({ id: 1, link: 'https://example.com/post-a/', content: '<p>No links here</p>' }),
+      mockPost({ id: 2, link: 'https://example.com/post-b/', content: '<p>Also no links</p>' })
+    ]);
+
+    const res = await call('wp_audit_internal_link_equity', { post_types: ['post'] });
+    const data = parseResult(res);
+    expect(data.orphan_pages.count).toBe(2);
+  });
+
+  it('detects well-linked pages as non-orphans', async () => {
+    mockLinkFlow([
+      mockPost({ id: 1, link: 'https://example.com/post-a/', content: '<p>Link to <a href="https://example.com/post-b/">B</a></p>' }),
+      mockPost({ id: 2, link: 'https://example.com/post-b/', content: '<p>Link to <a href="https://example.com/post-a/">A</a></p>' })
+    ]);
+
+    const res = await call('wp_audit_internal_link_equity', { post_types: ['post'] });
+    const data = parseResult(res);
+    expect(data.orphan_pages.count).toBe(0);
+  });
+
+  it('identifies under-linked important content (>800 words, <3 inbound)', async () => {
+    const longContent = '<p>' + 'word '.repeat(1000) + '</p>';
+    mockLinkFlow([
+      mockPost({ id: 1, link: 'https://example.com/important/', content: longContent }),
+      mockPost({ id: 2, link: 'https://example.com/other/', content: '<p>Short post here.</p>' })
+    ]);
+
+    const res = await call('wp_audit_internal_link_equity', { post_types: ['post'] });
+    const data = parseResult(res);
+    // Post 1 has >800 words and 0 inbound links → under-linked
+    expect(data.under_linked_important.count).toBeGreaterThan(0);
+    expect(data.under_linked_important.pages[0].word_count).toBeGreaterThan(800);
+  });
+
+  it('computes distribution score 100 when no orphans', async () => {
+    mockLinkFlow([
+      mockPost({ id: 1, link: 'https://example.com/a/', content: '<p><a href="https://example.com/b/">B</a></p>' }),
+      mockPost({ id: 2, link: 'https://example.com/b/', content: '<p><a href="https://example.com/a/">A</a></p>' })
+    ]);
+
+    const res = await call('wp_audit_internal_link_equity', { post_types: ['post'] });
+    const data = parseResult(res);
+    expect(data.distribution_score).toBe(100);
+  });
+
+  it('returns recommendations for issues found', async () => {
+    mockLinkFlow([
+      mockPost({ id: 1, link: 'https://example.com/orphan/', content: '<p>No links</p>' })
+    ]);
+
+    const res = await call('wp_audit_internal_link_equity', { post_types: ['post'] });
+    const data = parseResult(res);
+    expect(data.recommendations.length).toBeGreaterThan(0);
+    expect(data.recommendations[0]).toContain('orphan');
+  });
+
+  it('handles total_pages_analyzed count', async () => {
+    mockLinkFlow(Array.from({ length: 5 }, (_, i) => mockPost({
+      id: i + 1,
+      link: `https://example.com/post-${i + 1}/`,
+      content: '<p>Content here</p>'
+    })));
+
+    const res = await call('wp_audit_internal_link_equity', { post_types: ['post'] });
+    const data = parseResult(res);
+    expect(data.total_pages_analyzed).toBe(5);
+  });
+});
+
+// =========================================================================
+// wp_suggest_content_cluster
+// =========================================================================
+
+describe('wp_suggest_content_cluster', () => {
+  function mockClusterPosts(posts) {
+    let firstPostCall = true;
+    fetch.mockImplementation((url) => {
+      const u = typeof url === 'string' ? url : url.toString();
+      // Only return posts on first /posts? call to avoid duplicates across post types
+      if (u.includes('/posts') && !u.includes('/pages') && firstPostCall) {
+        firstPostCall = false;
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve(posts),
+          text: () => Promise.resolve(JSON.stringify(posts))
+        });
+      }
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve([]),
+        text: () => Promise.resolve(JSON.stringify([]))
+      });
+    });
+  }
+
+  it('clusters posts around a keyword topic', async () => {
+    const posts = [
+      mockPost({ id: 1, title: 'SEO Best Practices Guide', content: '<p>SEO optimization search engine ranking keywords meta tags on-page SEO.</p>' }),
+      mockPost({ id: 2, title: 'Technical SEO Checklist', content: '<p>Technical SEO crawling indexing sitemap robots.txt structured data SEO.</p>' }),
+      mockPost({ id: 3, title: 'Cooking Recipes Collection', content: '<p>Cooking recipes kitchen ingredients preparation meal dinner lunch.</p>' })
+    ];
+    mockClusterPosts(posts);
+
+    const res = await call('wp_suggest_content_cluster', { topic: 'SEO', similarity_threshold: 0.01 });
+    const data = parseResult(res);
+    expect(data.seed.type).toBe('keyword');
+    // With very low threshold, SEO-related posts should cluster
+    expect(data.cluster_size).toBeGreaterThanOrEqual(0);
+  });
+
+  it('clusters around a post_id seed', async () => {
+    const posts = [
+      mockPost({ id: 1, title: 'WordPress Performance Guide', content: '<p>WordPress performance optimization caching speed plugins themes.</p>' }),
+      mockPost({ id: 2, title: 'Speed Up WordPress Site', content: '<p>Speed WordPress cache CDN minification performance optimization.</p>' }),
+      mockPost({ id: 3, title: 'About Our Company', content: '<p>Company history team mission values contact information office.</p>' })
+    ];
+    mockClusterPosts(posts);
+
+    const res = await call('wp_suggest_content_cluster', { post_id: 1 });
+    const data = parseResult(res);
+    expect(data.seed.type).toBe('post');
+    expect(data.seed.post_id).toBe(1);
+  });
+
+  it('suggests pillar post (highest word count)', async () => {
+    const posts = [
+      mockPost({ id: 1, title: 'Short SEO Tip', content: '<p>SEO tip search engine optimization keywords.</p>' }),
+      mockPost({ id: 2, title: 'Complete SEO Guide', content: '<p>' + 'SEO optimization search engine ranking keywords '.repeat(100) + '</p>' })
+    ];
+    mockClusterPosts(posts);
+
+    const res = await call('wp_suggest_content_cluster', { topic: 'SEO', similarity_threshold: 0.01 });
+    const data = parseResult(res);
+    if (data.suggested_pillar) {
+      expect(data.suggested_pillar.word_count).toBeGreaterThan(0);
+    }
+  });
+
+  it('returns similarity bands breakdown', async () => {
+    const posts = [
+      mockPost({ id: 1, title: 'React Hooks Tutorial', content: '<p>React hooks useState useEffect components state management React.</p>' }),
+      mockPost({ id: 2, title: 'React Context API Guide', content: '<p>React context API state management components provider consumer React.</p>' }),
+      mockPost({ id: 3, title: 'JavaScript Basics', content: '<p>JavaScript variables functions loops arrays objects DOM manipulation.</p>' })
+    ];
+    mockClusterPosts(posts);
+
+    const res = await call('wp_suggest_content_cluster', { topic: 'React' });
+    const data = parseResult(res);
+    expect(data.similarity_bands).toBeDefined();
+    expect(data.similarity_bands.high).toBeDefined();
+    expect(data.similarity_bands.medium).toBeDefined();
+    expect(data.similarity_bands.low).toBeDefined();
+  });
+
+  it('throws error when neither topic nor post_id provided', async () => {
+    const res = await call('wp_suggest_content_cluster', {});
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('topic');
+  });
+
+  it('handles empty results gracefully', async () => {
+    mockClusterPosts([]);
+
+    const res = await call('wp_suggest_content_cluster', { topic: 'nonexistent_xyz' });
+    const data = parseResult(res);
+    expect(data.cluster_size).toBe(0);
+  });
+});
+
+// =========================================================================
+// Cross-cutting / additional coverage
+// =========================================================================
+
+describe('Editorial Intelligence additional coverage', () => {
+  it('wp_suggest_content_updates returns total_analyzed field', async () => {
+    fetch.mockImplementation(() => Promise.resolve({
+      ok: true, status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => Promise.resolve([
+        mockPost({ id: 1, modified: '2024-01-01T10:00:00', date: '2024-01-01T10:00:00', content: '<p>' + 'word '.repeat(200) + '</p>' })
+      ]),
+      text: () => Promise.resolve('[]')
+    }));
+
+    const res = await call('wp_suggest_content_updates', { months: 3 });
+    const data = parseResult(res);
+    expect(data.total_analyzed).toBeGreaterThanOrEqual(1);
+    expect(data.stale_threshold_months).toBe(3);
+  });
+
+  it('wp_audit_author_consistency returns total_authors_analyzed', async () => {
+    fetch.mockImplementation((url) => {
+      const u = typeof url === 'string' ? url : url.toString();
+      if (u.includes('/users')) {
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve([]),
+          text: () => Promise.resolve('[]')
+        });
+      }
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve([]),
+        text: () => Promise.resolve('[]')
+      });
+    });
+
+    const res = await call('wp_audit_author_consistency');
+    const data = parseResult(res);
+    expect(data.total_authors_analyzed).toBe(0);
+    expect(data.authors).toHaveLength(0);
+  });
+
+  it('wp_build_editorial_calendar returns monthly_breakdown', async () => {
+    const posts = Array.from({ length: 6 }, (_, i) => mockPost({
+      id: i + 1,
+      date: `2025-${String(i + 1).padStart(2, '0')}-15T10:00:00`,
+      categories: [1]
+    }));
+    fetch.mockImplementation((url) => {
+      const u = typeof url === 'string' ? url : url.toString();
+      if (u.includes('status=future')) {
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve([]),
+          text: () => Promise.resolve('[]')
+        });
+      }
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve(posts),
+        text: () => Promise.resolve(JSON.stringify(posts))
+      });
+    });
+
+    const res = await call('wp_build_editorial_calendar');
+    const data = parseResult(res);
+    expect(data.publishing_pattern.monthly_breakdown).toBeDefined();
+    expect(Object.keys(data.publishing_pattern.monthly_breakdown).length).toBeGreaterThan(0);
+  });
+
+  it('wp_audit_internal_link_equity reports outbound_links on orphans', async () => {
+    let firstPostCall = true;
+    fetch.mockImplementation((url) => {
+      const u = typeof url === 'string' ? url : url.toString();
+      if (u.includes('/posts') && u.includes('page=1') && firstPostCall) {
+        firstPostCall = false;
+        return Promise.resolve({
+          ok: true, status: 200,
+          headers: { get: () => 'application/json' },
+          json: () => Promise.resolve([
+            mockPost({ id: 1, link: 'https://example.com/linker/', content: '<p><a href="https://example.com/target/">Link</a></p>' }),
+            mockPost({ id: 2, link: 'https://example.com/target/', content: '<p>No outbound links</p>' })
+          ]),
+          text: () => Promise.resolve('[]')
+        });
+      }
+      return Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => Promise.resolve([]),
+        text: () => Promise.resolve('[]')
+      });
+    });
+
+    const res = await call('wp_audit_internal_link_equity', { post_types: ['post'] });
+    const data = parseResult(res);
+    // Post 1 has 1 inbound (none) → orphan with 1 outbound
+    const orphan = data.orphan_pages.pages.find(p => p.id === 1);
+    expect(orphan).toBeDefined();
+    expect(orphan.outbound_links).toBe(1);
+  });
+});