@adsim/wordpress-mcp-server 3.1.0 → 4.5.0

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

@@ -0,0 +1,150 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, 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(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); });
+
+function makePost(content) {
+  return {
+    id: 1, title: { rendered: 'Test Post' }, slug: 'test-post', status: 'publish',
+    link: 'https://test.example.com/test-post/',
+    content: { rendered: content },
+    meta: {}
+  };
+}
+
+// =========================================================================
+// wp_audit_heading_structure
+// =========================================================================
+
+describe('wp_audit_heading_structure', () => {
+  it('SUCCESS — clean heading structure', async () => {
+    mockSuccess(makePost('<h2>Introduction</h2><p>Text.</p><h3>Details</h3><p>More text.</p><h2>Conclusion</h2><p>End.</p>'));
+
+    const res = await call('wp_audit_heading_structure', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data.score).toBe(100);
+    expect(data.issues).toHaveLength(0);
+    expect(data.headings).toHaveLength(3);
+    expect(data.summary.h2_count).toBe(2);
+    expect(data.summary.h3_count).toBe(1);
+  });
+
+  it('ISSUE — H1 in content', async () => {
+    mockSuccess(makePost('<h1>Bad Title</h1><h2>Section</h2><p>Text.</p>'));
+
+    const res = await call('wp_audit_heading_structure', { id: 1 });
+    const data = parseResult(res);
+
+    const h1Issue = data.issues.find(i => i.type === 'h1_in_content');
+    expect(h1Issue).toBeDefined();
+    expect(h1Issue.count).toBe(1);
+    expect(data.score).toBeLessThan(100);
+  });
+
+  it('ISSUE — heading level skip', async () => {
+    mockSuccess(makePost('<h2>Section</h2><h4>Subsub</h4><p>Text.</p>'));
+
+    const res = await call('wp_audit_heading_structure', { id: 1 });
+    const data = parseResult(res);
+
+    const skipIssue = data.issues.find(i => i.type === 'heading_skip');
+    expect(skipIssue).toBeDefined();
+    expect(skipIssue.from).toBe('H2');
+    expect(skipIssue.to).toBe('H4');
+  });
+
+  it('ISSUE — empty heading', async () => {
+    mockSuccess(makePost('<h2></h2><h2>Good Heading</h2>'));
+
+    const res = await call('wp_audit_heading_structure', { id: 1 });
+    const data = parseResult(res);
+
+    const emptyIssue = data.issues.find(i => i.type === 'empty_heading');
+    expect(emptyIssue).toBeDefined();
+    expect(emptyIssue.count).toBe(1);
+  });
+
+  it('ISSUE — keyword stuffing in H2s', async () => {
+    mockSuccess(makePost(
+      '<h2>Best SEO Tips</h2><h2>SEO Tips Guide</h2><h2>SEO Tips Tutorial</h2><h2>More Stuff</h2>'
+    ));
+
+    const res = await call('wp_audit_heading_structure', { id: 1, focus_keyword: 'SEO Tips' });
+    const data = parseResult(res);
+
+    const stuffing = data.issues.find(i => i.type === 'keyword_stuffing');
+    expect(stuffing).toBeDefined();
+    expect(stuffing.count).toBe(3);
+  });
+
+  it('ISSUE — no H2 headings', async () => {
+    mockSuccess(makePost('<h3>Minor heading</h3><p>Text.</p>'));
+
+    const res = await call('wp_audit_heading_structure', { id: 1 });
+    const data = parseResult(res);
+
+    const noH2 = data.issues.find(i => i.type === 'no_h2');
+    expect(noH2).toBeDefined();
+    expect(data.summary.h2_count).toBe(0);
+  });
+
+  it('ISSUE — keyword absent from all H2s', async () => {
+    mockSuccess(makePost('<h2>Introduction</h2><h2>Conclusion</h2>'));
+
+    const res = await call('wp_audit_heading_structure', { id: 1, focus_keyword: 'WordPress' });
+    const data = parseResult(res);
+
+    const absent = data.issues.find(i => i.type === 'keyword_absent_h2');
+    expect(absent).toBeDefined();
+    expect(absent.message).toContain('WordPress');
+  });
+
+  it('SUCCESS — correct score with multiple deductions', async () => {
+    // H1 in content: -20, heading skip (H1→H3): -10, empty heading: -10, no_h2: -15 → 45
+    mockSuccess(makePost('<h1>Bad H1</h1><h3>Skip</h3><h3></h3>'));
+
+    const res = await call('wp_audit_heading_structure', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data.score).toBe(45);
+  });
+
+  it('SUCCESS — multiple issues combined', async () => {
+    mockSuccess(makePost(
+      '<h1>Bad</h1><h2>SEO SEO SEO</h2><h4>Skip</h4><h2></h2><h2>SEO keyword</h2><h2>SEO again</h2>'
+    ));
+
+    const res = await call('wp_audit_heading_structure', { id: 1, focus_keyword: 'SEO' });
+    const data = parseResult(res);
+
+    const issueTypes = data.issues.map(i => i.type);
+    expect(issueTypes).toContain('h1_in_content');
+    expect(issueTypes).toContain('heading_skip');
+    expect(issueTypes).toContain('empty_heading');
+    expect(data.score).toBeLessThan(100);
+  });
+
+  it('AUDIT — logs audit entry', async () => {
+    mockSuccess(makePost('<h2>Hello</h2>'));
+
+    await call('wp_audit_heading_structure', { id: 1 });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_heading_structure');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_heading_structure');
+  });
+});

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

@@ -0,0 +1,123 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, 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(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); });
+
+// =========================================================================
+// wp_audit_media_seo
+// =========================================================================
+
+describe('wp_audit_media_seo', () => {
+  it('SUCCESS — empty audit when no images', async () => {
+    mockSuccess([]);
+
+    const res = await call('wp_audit_media_seo');
+    const data = parseResult(res);
+
+    expect(data.summary.total_audited).toBe(0);
+    expect(data.summary.average_score).toBe(0);
+    expect(data.media).toHaveLength(0);
+  });
+
+  it('SUCCESS — detects missing alt text', async () => {
+    mockSuccess([
+      { id: 1, title: { rendered: 'Photo' }, source_url: 'https://test.example.com/wp-content/uploads/photo.jpg', alt_text: '', media_details: {} }
+    ]);
+
+    const res = await call('wp_audit_media_seo');
+    const data = parseResult(res);
+
+    expect(data.media[0].issues).toContain('missing_alt');
+    expect(data.summary.issues_breakdown.missing_alt).toBe(1);
+  });
+
+  it('SUCCESS — detects filename used as alt text', async () => {
+    mockSuccess([
+      { id: 2, title: { rendered: 'My Photo' }, source_url: 'https://test.example.com/wp-content/uploads/my-photo.jpg', alt_text: 'my photo', media_details: {} }
+    ]);
+
+    const res = await call('wp_audit_media_seo');
+    const data = parseResult(res);
+
+    expect(data.media[0].issues).toContain('filename_as_alt');
+    expect(data.summary.issues_breakdown.filename_as_alt).toBe(1);
+  });
+
+  it('SUCCESS — detects alt text too short', async () => {
+    mockSuccess([
+      { id: 3, title: { rendered: 'Icon' }, source_url: 'https://test.example.com/wp-content/uploads/icon.png', alt_text: 'img', media_details: {} }
+    ]);
+
+    const res = await call('wp_audit_media_seo');
+    const data = parseResult(res);
+
+    expect(data.media[0].issues).toContain('alt_too_short');
+    expect(data.summary.issues_breakdown.alt_too_short).toBe(1);
+  });
+
+  it('SUCCESS — scans inline images when post_id provided', async () => {
+    // 1. GET media library (empty)
+    mockSuccess([]);
+    // 2. GET post content with inline images
+    mockSuccess({
+      id: 10, title: { rendered: 'Blog Post' },
+      content: { rendered: '<p>Text</p><img src="https://test.example.com/inline.jpg" alt=""><img src="https://test.example.com/good.jpg" alt="A good image description">' }
+    });
+
+    const res = await call('wp_audit_media_seo', { post_id: 10 });
+    const data = parseResult(res);
+
+    expect(data.inline_images).toHaveLength(2);
+    expect(data.inline_images[0].alt).toBe('');
+    expect(data.inline_images[1].alt).toBe('A good image description');
+  });
+
+  it('SUCCESS — calculates correct scores', async () => {
+    mockSuccess([
+      { id: 1, title: { rendered: 'Good' }, source_url: 'https://test.example.com/wp-content/uploads/landscape.jpg', alt_text: 'Beautiful mountain landscape at sunset', media_details: {} },
+      { id: 2, title: { rendered: 'Bad' }, source_url: 'https://test.example.com/wp-content/uploads/photo.jpg', alt_text: '', media_details: {} }
+    ]);
+
+    const res = await call('wp_audit_media_seo');
+    const data = parseResult(res);
+
+    expect(data.media[0].score).toBe(100);
+    expect(data.media[1].score).toBe(60);
+    expect(data.summary.average_score).toBe(80);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    mockSuccess([]);
+
+    await call('wp_audit_media_seo');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_media_seo');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_media_seo');
+  });
+
+  it('ERROR — logs error on API failure', async () => {
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_media_seo');
+    expect(res.isError).toBe(true);
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_media_seo');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+});

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

@@ -0,0 +1,175 @@
+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 { mockSuccess, mockError, getAuditLogs, makeRequest, 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(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); _testSetTarget(null); });
+
+// =========================================================================
+// Helpers
+// =========================================================================
+
+function makePost(id, content) {
+  return {
+    id, title: { rendered: `Post ${id}` },
+    link: `https://mysite.example.com/post-${id}/`,
+    content: { rendered: content }
+  };
+}
+
+// =========================================================================
+// wp_audit_outbound_links
+// =========================================================================
+
+describe('wp_audit_outbound_links', () => {
+  it('STATUS — no_outbound when article has no external links', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = '<p>Just text, no links at all.</p>';
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    expect(data.articles[0].status).toBe('no_outbound');
+    expect(data.articles[0].outbound_count).toBe(0);
+    expect(data.by_status.no_outbound).toBe(1);
+  });
+
+  it('STATUS — good when article has appropriate external links', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = '<p>See <a href="https://external.com/page">external</a> and <a href="https://other.com/page">other</a>.</p>';
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    expect(data.articles[0].status).toBe('good');
+    expect(data.articles[0].outbound_count).toBe(2);
+    expect(data.by_status.good).toBe(1);
+  });
+
+  it('STATUS — excessive when too many external links', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // Generate 20 external links
+    const links = Array.from({ length: 20 }, (_, i) =>
+      `<a href="https://site${i}.com/page">link${i}</a>`
+    ).join(' ');
+    const html = `<p>${links}</p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links', { max_outbound: 15 });
+    const data = parseResult(res);
+
+    expect(data.articles[0].status).toBe('excessive');
+    expect(data.articles[0].outbound_count).toBe(20);
+    expect(data.by_status.excessive).toBe(1);
+  });
+
+  it('FILTER — internal links NOT counted as external', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = `<p>
+      <a href="https://mysite.example.com/other-post/">internal</a>
+      <a href="https://external.com/page">external</a>
+    </p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    // Only the external link should be counted
+    expect(data.articles[0].outbound_count).toBe(1);
+    expect(data.articles[0].external_domains).toContain('external.com');
+    expect(data.articles[0].external_domains).not.toContain('mysite.example.com');
+  });
+
+  it('AUTH — authoritative domains identified correctly', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = `<p>
+      <a href="https://en.wikipedia.org/wiki/SEO">wiki</a>
+      <a href="https://www.cdc.gov/health">gov</a>
+      <a href="https://randomsite.com/page">random</a>
+    </p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    expect(data.articles[0].authoritative_count).toBe(2);
+    expect(data.posts_with_authoritative_sources).toBe(1);
+    // Top cited domains should include authoritative flag
+    const wikiDomain = data.top_cited_domains.find(d => d.domain === 'en.wikipedia.org');
+    expect(wikiDomain).toBeDefined();
+    expect(wikiDomain.is_authoritative).toBe(true);
+  });
+
+  it('RANKING — top_cited_domains sorted by count DESC', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = `<p>
+      <a href="https://siteA.com/1">a1</a>
+      <a href="https://siteB.com/1">b1</a>
+      <a href="https://siteB.com/2">b2</a>
+      <a href="https://siteC.com/1">c1</a>
+      <a href="https://siteC.com/2">c2</a>
+      <a href="https://siteC.com/3">c3</a>
+    </p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    expect(data.top_cited_domains[0].domain).toBe('sitec.com');
+    expect(data.top_cited_domains[0].count).toBe(3);
+    expect(data.top_cited_domains[1].domain).toBe('siteb.com');
+    expect(data.top_cited_domains[1].count).toBe(2);
+  });
+
+  it('RATIO — outbound_ratio calculated correctly', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // 100 words + 2 external links → ratio = 2 / (100/100) = 2.0
+    const words = Array(100).fill('word').join(' ');
+    const html = `<p>${words} <a href="https://ext1.com/p">ext1</a> <a href="https://ext2.com/p">ext2</a></p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    // Word count includes link text, so it's slightly more than 100
+    expect(data.articles[0].outbound_ratio).toBeGreaterThan(0);
+    expect(typeof data.articles[0].outbound_ratio).toBe('number');
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePost(1, '<p>Text.</p>')]);
+
+    await call('wp_audit_outbound_links');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_outbound_links');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_seo');
+  });
+
+  it('ERROR — logs error on API failure', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_outbound_links');
+    expect(res.isError).toBe(true);
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_outbound_links');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+});

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

@@ -0,0 +1,173 @@
+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 { mockSuccess, mockError, getAuditLogs, makeRequest, 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(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); _testSetTarget(null); });
+
+// =========================================================================
+// Helpers
+// =========================================================================
+
+function makeTag(id, name, count = 5) {
+  return { id, name, slug: name.toLowerCase().replace(/\s+/g, '-'), count, description: '' };
+}
+
+function makeCategory(id, name, count = 5, description = 'A category about ' + name) {
+  return { id, name, slug: name.toLowerCase().replace(/\s+/g, '-'), count, description };
+}
+
+// =========================================================================
+// wp_audit_taxonomies
+// =========================================================================
+
+describe('wp_audit_taxonomies', () => {
+  it('SUCCESS — no issues detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'WordPress', 10), makeTag(2, 'SEO', 8)]);
+    mockSuccess([makeCategory(1, 'Tutorials', 15, 'Step by step tutorials'), makeCategory(2, 'News', 12, 'Latest news')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.total_issues).toBe(0);
+    expect(data.crawl_waste_score).toBe(0);
+  });
+
+  it('ISSUE — empty tag detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'WordPress', 0), makeTag(2, 'SEO', 8)]);
+    mockSuccess([makeCategory(1, 'Tutorials', 15, 'Tutorials desc')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.tags.issues.empty).toHaveLength(1);
+    expect(data.tags.issues.empty[0].name).toBe('WordPress');
+    expect(data.tags.issues.empty[0].issue_type).toBe('empty');
+  });
+
+  it('ISSUE — single_post tag detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'Niche Topic', 1)]);
+    mockSuccess([makeCategory(1, 'General', 10, 'General desc')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.tags.issues.single_post).toHaveLength(1);
+    expect(data.tags.issues.single_post[0].issue_type).toBe('single_post');
+  });
+
+  it('ISSUE — category missing_description detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'SEO', 10)]);
+    mockSuccess([makeCategory(1, 'Tutorials', 15, ''), makeCategory(2, 'News', 12, 'Has description')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.categories.issues.missing_description).toHaveLength(1);
+    expect(data.categories.issues.missing_description[0].name).toBe('Tutorials');
+  });
+
+  it('DEDUP — exact duplicates grouped', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'seo', 5), makeTag(2, 'SEO', 3), makeTag(3, 'WordPress', 10)]);
+    mockSuccess([makeCategory(1, 'General', 10, 'Desc')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.tags.issues.duplicate_groups.length).toBeGreaterThanOrEqual(1);
+    const group = data.tags.issues.duplicate_groups[0];
+    expect(group.terms.length).toBeGreaterThanOrEqual(2);
+    expect(group.similarity).toBe('exact');
+  });
+
+  it('DEDUP — near duplicates via Levenshtein grouped', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // 'wordpress' and 'wordpres' differ by 1 char, both >= 4 chars
+    mockSuccess([makeTag(1, 'WordPress', 5), makeTag(2, 'Wordpres', 3)]);
+    mockSuccess([makeCategory(1, 'General', 10, 'Desc')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.tags.issues.duplicate_groups.length).toBeGreaterThanOrEqual(1);
+    const group = data.tags.issues.duplicate_groups[0];
+    expect(group.similarity).toBe('near');
+  });
+
+  it('PARAM — check_tags: false skips tags', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeCategory(1, 'Tutorials', 15, 'Desc')]);
+
+    const res = await call('wp_audit_taxonomies', { check_tags: false });
+    const data = parseResult(res);
+
+    expect(data.tags).toBeUndefined();
+    expect(data.categories).toBeDefined();
+  });
+
+  it('PARAM — check_categories: false skips categories', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'SEO', 10)]);
+
+    const res = await call('wp_audit_taxonomies', { check_categories: false });
+    const data = parseResult(res);
+
+    expect(data.categories).toBeUndefined();
+    expect(data.tags).toBeDefined();
+  });
+
+  it('SCORE — crawl_waste_score calculated correctly', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // 2 tags: 1 empty (issue) + 1 ok, 2 cats: 1 missing_desc (issue) + 1 ok → 2 issues / 4 terms = 50%
+    mockSuccess([makeTag(1, 'Empty', 0), makeTag(2, 'OK', 10)]);
+    mockSuccess([makeCategory(1, 'NoDesc', 5, ''), makeCategory(2, 'WithDesc', 5, 'Good')]);
+
+    const res = await call('wp_audit_taxonomies', { detect_duplicates: false });
+    const data = parseResult(res);
+
+    expect(data.crawl_waste_score).toBe(50);
+  });
+
+  it('AUDIT — logs success and error', async () => {
+    // Success
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'SEO', 10)]);
+    mockSuccess([makeCategory(1, 'General', 5, 'Desc')]);
+
+    await call('wp_audit_taxonomies');
+
+    let logs = getAuditLogs();
+    let entry = logs.find(l => l.tool === 'wp_audit_taxonomies');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_seo');
+
+    // Error
+    fetch.mockReset();
+    consoleSpy.mockClear();
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_taxonomies');
+    expect(res.isError).toBe(true);
+
+    logs = getAuditLogs();
+    entry = logs.find(l => l.tool === 'wp_audit_taxonomies');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+});