@gravitykit/block-mcp 2.0.0-beta

package/src/__tests__/tools/write/update_block.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Tool tests: update_block
+ *
+ * Covers:
+ *   - Input validation (post_id, flat_index/ref XOR, attributes/innerHTML)
+ *   - Index path → client.updateBlock
+ *   - Ref path → client.updateBlockByRef
+ *   - Enricher wiring (block_name triggers enrichBlock)
+ *   - Response shape (success, saved snapshot, revision IDs)
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleWriteTool } from '../../../tools/write.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+import { assertBlockUpdateResponse } from '../../helpers/schema-asserts.js';
+
+vi.mock('../../../enrichers.js', () => ({
+  enrichBlock: vi.fn(async (block: any) => ({
+    ...block,
+    attributes: { ...block.attributes, enriched: true },
+  })),
+  enrichBlocks: vi.fn(async (blocks: any[]) =>
+    blocks.map((b: any) => ({ ...b, attributes: { ...b.attributes, enriched: true } }))
+  ),
+}));
+
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+
+const UPDATE_RESPONSE = {
+  success: true,
+  block: { index: 1, name: 'core/heading', attributes: { level: 3 }, ref: 'blk_head0001' },
+  saved: {
+    flat_index: 1, block_name: 'core/heading',
+    attributes: { level: 3 }, inner_html: '<h3>Title</h3>', is_dynamic: false, ref: 'blk_head0001',
+  },
+  before_revision_id: 100,
+  revision_id: 101,
+};
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('update_block — validation', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('requires post_id', async () => {
+    await expect(handleWriteTool('update_block', { flat_index: 0, attributes: {} }, client as any))
+      .rejects.toThrow('post_id');
+  });
+
+  it('requires flat_index OR ref (not neither)', async () => {
+    await expect(handleWriteTool('update_block', { post_id: 1, attributes: {} }, client as any))
+      .rejects.toThrow(/Provide either flat_index/);
+  });
+
+  it('rejects when both flat_index and ref provided', async () => {
+    await expect(
+      handleWriteTool('update_block', { post_id: 1, flat_index: 0, ref: 'blk_x', attributes: {} }, client as any)
+    ).rejects.toThrow(/flat_index OR ref, not both/);
+  });
+
+  it('rejects empty-string ref (treats as absent)', async () => {
+    await expect(
+      handleWriteTool('update_block', { post_id: 1, ref: '', attributes: {} }, client as any)
+    ).rejects.toThrow(/Provide either flat_index/);
+  });
+
+  it('requires attributes or innerHTML', async () => {
+    await expect(handleWriteTool('update_block', { post_id: 1, flat_index: 0 }, client as any))
+      .rejects.toThrow(/attributes or innerHTML/);
+  });
+
+  it('rejects negative flat_index', async () => {
+    await expect(
+      handleWriteTool('update_block', { post_id: 1, flat_index: -1, attributes: {} }, client as any)
+    ).rejects.toThrow(/Provide either flat_index/);
+  });
+
+  it('rejects NaN flat_index', async () => {
+    await expect(
+      handleWriteTool('update_block', { post_id: 1, flat_index: NaN, attributes: {} }, client as any)
+    ).rejects.toThrow(/Provide either flat_index/);
+  });
+});
+
+describe('update_block — index path', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); client.updateBlock.mockResolvedValue(UPDATE_RESPONSE); vi.clearAllMocks(); });
+
+  it('routes to updateBlock (not updateBlockByRef)', async () => {
+    await handleWriteTool('update_block', { post_id: 1, flat_index: 5, attributes: { level: 3 } }, client as any);
+    expect(client.updateBlock).toHaveBeenCalledWith(1, 5, { attributes: { level: 3 }, innerHTML: undefined });
+    expect(client.updateBlockByRef).not.toHaveBeenCalled();
+  });
+
+  it('passes innerHTML through index path', async () => {
+    await handleWriteTool('update_block', { post_id: 1, flat_index: 2, innerHTML: '<p>Hi</p>' }, client as any);
+    expect(client.updateBlock).toHaveBeenCalledWith(1, 2, { attributes: undefined, innerHTML: '<p>Hi</p>' });
+  });
+
+  it('passes both attributes and innerHTML', async () => {
+    await handleWriteTool('update_block', {
+      post_id: 1, flat_index: 0, attributes: { level: 2 }, innerHTML: '<h2>Title</h2>'
+    }, client as any);
+    expect(client.updateBlock).toHaveBeenCalledWith(1, 0, { attributes: { level: 2 }, innerHTML: '<h2>Title</h2>' });
+  });
+
+  it('flat_index=0 is a valid target', async () => {
+    await handleWriteTool('update_block', { post_id: 1, flat_index: 0, attributes: { level: 1 } }, client as any);
+    expect(client.updateBlock).toHaveBeenCalledWith(1, 0, expect.any(Object));
+  });
+});
+
+describe('update_block — ref path', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); client.updateBlockByRef.mockResolvedValue(UPDATE_RESPONSE); vi.clearAllMocks(); });
+
+  it('routes to updateBlockByRef (not updateBlock)', async () => {
+    await handleWriteTool('update_block', { post_id: 1, ref: 'blk_abc12345', attributes: { level: 3 } }, client as any);
+    expect(client.updateBlockByRef).toHaveBeenCalledWith(1, 'blk_abc12345', { attributes: { level: 3 }, innerHTML: undefined });
+    expect(client.updateBlock).not.toHaveBeenCalled();
+  });
+
+  it('passes innerHTML through ref path', async () => {
+    await handleWriteTool('update_block', { post_id: 1, ref: 'blk_x', innerHTML: '<h2>hi</h2>' }, client as any);
+    expect(client.updateBlockByRef).toHaveBeenCalledWith(1, 'blk_x', { attributes: undefined, innerHTML: '<h2>hi</h2>' });
+  });
+});
+
+describe('update_block — enricher wiring', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); client.updateBlock.mockResolvedValue(UPDATE_RESPONSE); vi.clearAllMocks(); });
+
+  it('skips enricher when block_name is absent', async () => {
+    const enrichers = await import('../../../enrichers.js');
+    const localEnrichBlock = enrichers.enrichBlock as ReturnType<typeof vi.fn>;
+    localEnrichBlock.mockClear();
+    await handleWriteTool('update_block', { post_id: 1, flat_index: 0, attributes: { level: 2 } }, client as any);
+    expect(localEnrichBlock).not.toHaveBeenCalled();
+  });
+
+  it('calls enrichBlock when block_name is provided', async () => {
+    const enrichers = await import('../../../enrichers.js');
+    const localEnrichBlock = enrichers.enrichBlock as ReturnType<typeof vi.fn>;
+    localEnrichBlock.mockClear();
+    await handleWriteTool('update_block', {
+      post_id: 1, flat_index: 0, block_name: 'core/heading', attributes: { level: 2 },
+    }, client as any);
+    expect(localEnrichBlock).toHaveBeenCalledWith({ name: 'core/heading', attributes: { level: 2 } });
+  });
+
+  it('enricher-updated attributes reach the client', async () => {
+    await handleWriteTool('update_block', {
+      post_id: 1, flat_index: 0, block_name: 'core/heading', attributes: { level: 2 },
+    }, client as any);
+    const call = client.updateBlock.mock.calls[0] as unknown[];
+    const data = call[2] as { attributes: Record<string, unknown> };
+    expect(data.attributes).toMatchObject({ level: 2, enriched: true });
+  });
+
+  it('enricher can update innerHTML', async () => {
+    const enrichers = await import('../../../enrichers.js');
+    const localEnrichBlock = enrichers.enrichBlock as ReturnType<typeof vi.fn>;
+    localEnrichBlock.mockResolvedValueOnce({
+      name: 'core/heading',
+      attributes: { level: 2, enriched: true },
+      innerHTML: '<h2>Enriched</h2>',
+    });
+    await handleWriteTool('update_block', {
+      post_id: 1, flat_index: 0, block_name: 'core/heading',
+      attributes: { level: 2 }, innerHTML: '<h2>Original</h2>',
+    }, client as any);
+    expect(client.updateBlock).toHaveBeenCalledWith(1, 0, {
+      attributes: { level: 2, enriched: true }, innerHTML: '<h2>Enriched</h2>',
+    });
+  });
+});
+
+describe('update_block — response shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); client.updateBlock.mockResolvedValue(UPDATE_RESPONSE); vi.clearAllMocks(); });
+
+  it('returns a valid BlockUpdateResponse shape', async () => {
+    const result = await handleWriteTool('update_block', {
+      post_id: 1, flat_index: 1, attributes: { level: 3 }
+    }, client as any);
+    assertBlockUpdateResponse(result);
+  });
+
+  it('saved block matches expected shape', async () => {
+    const result = await handleWriteTool('update_block', {
+      post_id: 1, flat_index: 1, attributes: { level: 3 }
+    }, client as any) as any;
+    expect(result.saved.block_name).toBe('core/heading');
+    expect(result.saved.flat_index).toBe(1);
+    expect(result.saved.is_dynamic).toBe(false);
+  });
+
+  it('revision IDs are present', async () => {
+    const result = await handleWriteTool('update_block', {
+      post_id: 1, flat_index: 1, attributes: { level: 3 }
+    }, client as any) as any;
+    expect(result.before_revision_id).toBe(100);
+    expect(result.revision_id).toBe(101);
+  });
+});

package/src/__tests__/tools/write/update_blocks.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Tool tests: update_blocks (batch update)
+ *
+ * Covers:
+ *   - Input validation (post_id, non-empty updates, per-item ref/flat_index XOR)
+ *   - Per-item payload validation (must have attributes or innerHTML)
+ *   - Error message includes failing item index
+ *   - Correct forwarding of normalized items to client.updateBlocksBatch
+ *   - Enricher wiring for block_name items
+ *   - verbose flag forwarding
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleWriteTool } from '../../../tools/write.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+
+vi.mock('../../../enrichers.js', () => ({
+  enrichBlock: vi.fn(async (block: any) => ({
+    ...block,
+    attributes: { ...block.attributes, enriched: true },
+  })),
+  enrichBlocks: vi.fn(async (blocks: any[]) =>
+    blocks.map((b: any) => ({ ...b, attributes: { ...b.attributes, enriched: true } }))
+  ),
+}));
+
+describe('update_blocks — validation: post_id', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('requires post_id', async () => {
+    await expect(
+      handleWriteTool('update_blocks', { updates: [{ ref: 'blk_a', innerHTML: 'x' }] }, client as any)
+    ).rejects.toThrow('post_id');
+  });
+});
+
+describe('update_blocks — validation: updates array', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('rejects empty updates array', async () => {
+    await expect(
+      handleWriteTool('update_blocks', { post_id: 1, updates: [] }, client as any)
+    ).rejects.toThrow('non-empty');
+  });
+
+  it('rejects missing updates field', async () => {
+    await expect(
+      handleWriteTool('update_blocks', { post_id: 1 }, client as any)
+    ).rejects.toThrow('non-empty');
+  });
+});
+
+describe('update_blocks — per-item validation', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('rejects items missing both ref and flat_index', async () => {
+    await expect(
+      handleWriteTool('update_blocks', { post_id: 1, updates: [{ innerHTML: 'x' }] }, client as any)
+    ).rejects.toThrow('exactly one of ref or flat_index');
+  });
+
+  it('rejects items with both ref and flat_index', async () => {
+    await expect(
+      handleWriteTool('update_blocks', {
+        post_id: 1, updates: [{ ref: 'blk_a', flat_index: 0, innerHTML: 'x' }],
+      }, client as any)
+    ).rejects.toThrow('exactly one of ref or flat_index');
+  });
+
+  it('rejects items missing payload (no attributes or innerHTML)', async () => {
+    await expect(
+      handleWriteTool('update_blocks', { post_id: 1, updates: [{ ref: 'blk_a' }] }, client as any)
+    ).rejects.toThrow('attributes or innerHTML');
+  });
+
+  it('error message includes the failing item index', async () => {
+    await expect(
+      handleWriteTool('update_blocks', {
+        post_id: 1,
+        updates: [
+          { ref: 'blk_a', innerHTML: 'x' },
+          { ref: 'blk_b' }, // missing payload at index 1
+        ],
+      }, client as any)
+    ).rejects.toThrow('updates[1]');
+  });
+
+  it('error includes index for failing item deeper in the array', async () => {
+    await expect(
+      handleWriteTool('update_blocks', {
+        post_id: 1,
+        updates: [
+          { ref: 'blk_a', innerHTML: 'x' },
+          { ref: 'blk_b', attributes: { level: 2 } },
+          { innerHTML: 'y' }, // missing ref/flat_index at index 2
+        ],
+      }, client as any)
+    ).rejects.toThrow('updates[2]');
+  });
+});
+
+describe('update_blocks — forwarding to client', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('forwards normalized items to updateBlocksBatch', async () => {
+    await handleWriteTool('update_blocks', {
+      post_id: 42,
+      updates: [
+        { ref: 'blk_a', innerHTML: '<p>One</p>' },
+        { flat_index: 5, attributes: { level: 3 } },
+      ],
+    }, client as any);
+    expect(client.updateBlocksBatch).toHaveBeenCalledWith(42, [
+      { ref: 'blk_a', innerHTML: '<p>One</p>' },
+      { flat_index: 5, attributes: { level: 3 } },
+    ]);
+  });
+
+  it('omits verbose option when flag is not set (two-arg call)', async () => {
+    await handleWriteTool('update_blocks', {
+      post_id: 7, updates: [{ ref: 'blk_x', attributes: { level: 2 } }],
+    }, client as any);
+    expect(client.updateBlocksBatch.mock.calls[0]).toHaveLength(2);
+  });
+
+  it('forwards verbose:true when requested (three-arg call)', async () => {
+    await handleWriteTool('update_blocks', {
+      post_id: 7, updates: [{ ref: 'blk_x', attributes: { level: 2 } }], verbose: true,
+    }, client as any);
+    expect(client.updateBlocksBatch).toHaveBeenCalledWith(
+      7,
+      [{ ref: 'blk_x', attributes: { level: 2 } }],
+      { verbose: true }
+    );
+  });
+
+  it('treats non-boolean verbose as false (defensive)', async () => {
+    await handleWriteTool('update_blocks', {
+      post_id: 7, updates: [{ ref: 'blk_x', attributes: { level: 2 } }],
+      verbose: 'true' as unknown as boolean,
+    }, client as any);
+    expect(client.updateBlocksBatch.mock.calls[0]).toHaveLength(2);
+  });
+});
+
+describe('update_blocks — enricher wiring', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('enriches item attributes when block_name is supplied', async () => {
+    await handleWriteTool('update_blocks', {
+      post_id: 7,
+      updates: [{ ref: 'blk_x', block_name: 'core/heading', attributes: { level: 2 } }],
+    }, client as any);
+    const call = client.updateBlocksBatch.mock.calls[0] as unknown[];
+    const normalized = call[1] as Array<{ attributes: Record<string, unknown> }>;
+    expect(normalized[0].attributes).toEqual({ level: 2, enriched: true });
+  });
+
+  it('passes item through unchanged when block_name is absent', async () => {
+    await handleWriteTool('update_blocks', {
+      post_id: 7,
+      updates: [{ ref: 'blk_x', attributes: { level: 2 } }],
+    }, client as any);
+    const call = client.updateBlocksBatch.mock.calls[0] as unknown[];
+    const normalized = call[1] as Array<{ attributes: Record<string, unknown> }>;
+    expect(normalized[0].attributes).toEqual({ level: 2 });
+  });
+});

package/src/__tests__/tools/yoast/yoast_bulk_update_seo.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Tool tests: yoast_bulk_update_seo
+ *
+ * Covers:
+ *   - Schema: posts required
+ *   - Validation: rejects empty posts array
+ *   - Validation: rejects items missing post_id
+ *   - Request: normalized item list forwarded (extra fields stripped per-item)
+ *   - Response shape: array of per-post results
+ *   - Unknown tool throws
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { YOAST_TOOLS, handleYoastTool } from '../../../tools/yoast.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+import { yoastSEOResponse } from '../../fixtures/rest-responses.js';
+
+describe('yoast_bulk_update_seo — schema', () => {
+  it('exposes yoast_bulk_update_seo tool', () => {
+    expect(YOAST_TOOLS.map((t) => t.name)).toContain('yoast_bulk_update_seo');
+  });
+
+  it('requires posts in inputSchema', () => {
+    const tool = YOAST_TOOLS.find((t) => t.name === 'yoast_bulk_update_seo')!;
+    expect(tool.inputSchema.required).toContain('posts');
+  });
+});
+
+describe('yoast_bulk_update_seo — validation', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('rejects empty posts array', async () => {
+    await expect(handleYoastTool('yoast_bulk_update_seo', { posts: [] }, client as any))
+      .rejects.toThrow('non-empty');
+    expect(client.bulkUpdateYoastSEO).not.toHaveBeenCalled();
+  });
+
+  it('rejects items missing post_id', async () => {
+    await expect(handleYoastTool('yoast_bulk_update_seo', {
+      posts: [{ title: 'X' }],
+    }, client as any)).rejects.toThrow('post_id');
+    expect(client.bulkUpdateYoastSEO).not.toHaveBeenCalled();
+  });
+});
+
+describe('yoast_bulk_update_seo — request shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.bulkUpdateYoastSEO.mockResolvedValue([
+      { post_id: 1, success: true, seo: yoastSEOResponse },
+      { post_id: 2, success: true, seo: { ...yoastSEOResponse, post_id: 2 } },
+    ]);
+    vi.clearAllMocks();
+  });
+
+  it('forwards normalized item list (extra fields stripped per item)', async () => {
+    await handleYoastTool('yoast_bulk_update_seo', {
+      posts: [
+        { post_id: 1, title: 'A', evil_extra: 'strip me' },
+        { post_id: 2, noindex: false, focus_keyword: 'keyword' },
+      ],
+    }, client as any);
+    expect(client.bulkUpdateYoastSEO).toHaveBeenCalledWith([
+      { post_id: 1, title: 'A' },
+      { post_id: 2, noindex: false, focus_keyword: 'keyword' },
+    ]);
+  });
+
+  it('processes multiple posts in a single call', async () => {
+    await handleYoastTool('yoast_bulk_update_seo', {
+      posts: [
+        { post_id: 10, title: 'Page A' },
+        { post_id: 11, title: 'Page B' },
+        { post_id: 12, description: 'Meta C' },
+      ],
+    }, client as any);
+    const [items] = client.bulkUpdateYoastSEO.mock.calls[0] as [unknown[]];
+    expect(items).toHaveLength(3);
+  });
+});
+
+describe('yoast_bulk_update_seo — response shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.bulkUpdateYoastSEO.mockResolvedValue([
+      { post_id: 1, success: true, seo: yoastSEOResponse },
+    ]);
+    vi.clearAllMocks();
+  });
+
+  it('returns array of per-post results', async () => {
+    const result = await handleYoastTool('yoast_bulk_update_seo', {
+      posts: [{ post_id: 1, title: 'X' }],
+    }, client as any) as any[];
+    expect(Array.isArray(result)).toBe(true);
+    expect(result[0].post_id).toBe(1);
+    expect(result[0].success).toBe(true);
+  });
+});
+
+describe('yoast_bulk_update_seo — unknown tool', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); });
+
+  it('throws on unknown tool name', async () => {
+    await expect(handleYoastTool('unknown_tool', {}, client as any))
+      .rejects.toThrow('Unknown yoast tool');
+  });
+});

package/src/__tests__/tools/yoast/yoast_get_seo.test.ts

@@ -0,0 +1,78 @@
+/**
+ * Tool tests: yoast_get_seo
+ *
+ * Covers:
+ *   - Schema: tool exposed with post_id required
+ *   - Validation: post_id must be a number
+ *   - Request: post_id forwarded to client.getYoastSEO
+ *   - Response shape: post_id, title, description, seo_score, readability_score
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { YOAST_TOOLS, handleYoastTool } from '../../../tools/yoast.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+import { yoastSEOResponse } from '../../fixtures/rest-responses.js';
+
+describe('yoast_get_seo — schema', () => {
+  it('exposes yoast_get_seo tool', () => {
+    expect(YOAST_TOOLS.map((t) => t.name)).toContain('yoast_get_seo');
+  });
+
+  it('requires post_id in inputSchema', () => {
+    const tool = YOAST_TOOLS.find((t) => t.name === 'yoast_get_seo')!;
+    expect(tool.inputSchema.required).toContain('post_id');
+  });
+});
+
+describe('yoast_get_seo — validation', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('rejects missing post_id', async () => {
+    await expect(handleYoastTool('yoast_get_seo', {}, client as any)).rejects.toThrow('post_id');
+    expect(client.getYoastSEO).not.toHaveBeenCalled();
+  });
+
+  it('rejects string post_id (must be number)', async () => {
+    await expect(handleYoastTool('yoast_get_seo', { post_id: '42' }, client as any))
+      .rejects.toThrow('post_id');
+    expect(client.getYoastSEO).not.toHaveBeenCalled();
+  });
+});
+
+describe('yoast_get_seo — request shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.getYoastSEO.mockResolvedValue(yoastSEOResponse);
+    vi.clearAllMocks();
+  });
+
+  it('forwards post_id to client.getYoastSEO', async () => {
+    await handleYoastTool('yoast_get_seo', { post_id: 42 }, client as any);
+    expect(client.getYoastSEO).toHaveBeenCalledWith(42);
+  });
+});
+
+describe('yoast_get_seo — response shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.getYoastSEO.mockResolvedValue(yoastSEOResponse);
+    vi.clearAllMocks();
+  });
+
+  it('returns post_id, title, description, scores', async () => {
+    const result = await handleYoastTool('yoast_get_seo', { post_id: 42 }, client as any) as any;
+    expect(result.post_id).toBe(9999);
+    expect(result.title).toBe('SEO Title');
+    expect(result.description).toBe('Meta description.');
+    expect(result.seo_score).toBe(78);
+    expect(result.readability_score).toBe(65);
+  });
+
+  it('noindex can be null (tri-state)', async () => {
+    const result = await handleYoastTool('yoast_get_seo', { post_id: 42 }, client as any) as any;
+    expect(result.noindex).toBeNull();
+  });
+});

package/src/__tests__/tools/yoast/yoast_update_seo.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tool tests: yoast_update_seo
+ *
+ * Covers:
+ *   - Schema: post_id required
+ *   - Validation: post_id required
+ *   - Validation: at least one mutating Yoast field required
+ *   - Request: only known Yoast fields forwarded (extra fields stripped)
+ *   - noindex tri-state: null is preserved
+ *   - robots_advanced: unknown directives filtered out
+ *   - schema_page_type: out-of-enum values dropped
+ *   - Response shape
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { YOAST_TOOLS, handleYoastTool } from '../../../tools/yoast.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+import { yoastSEOResponse } from '../../fixtures/rest-responses.js';
+
+describe('yoast_update_seo — schema', () => {
+  it('exposes yoast_update_seo tool', () => {
+    expect(YOAST_TOOLS.map((t) => t.name)).toContain('yoast_update_seo');
+  });
+
+  it('requires post_id in inputSchema', () => {
+    const tool = YOAST_TOOLS.find((t) => t.name === 'yoast_update_seo')!;
+    expect(tool.inputSchema.required).toContain('post_id');
+  });
+});
+
+describe('yoast_update_seo — validation', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('requires post_id', async () => {
+    await expect(handleYoastTool('yoast_update_seo', { title: 'New' }, client as any))
+      .rejects.toThrow('post_id');
+    expect(client.updateYoastSEO).not.toHaveBeenCalled();
+  });
+
+  it('requires at least one Yoast mutating field', async () => {
+    await expect(handleYoastTool('yoast_update_seo', { post_id: 1 }, client as any))
+      .rejects.toThrow('at least one Yoast field');
+    expect(client.updateYoastSEO).not.toHaveBeenCalled();
+  });
+});
+
+describe('yoast_update_seo — request shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.updateYoastSEO.mockResolvedValue({ ...yoastSEOResponse, title: 'New' });
+    vi.clearAllMocks();
+  });
+
+  it('forwards known Yoast fields and strips unknown fields', async () => {
+    await handleYoastTool('yoast_update_seo', {
+      post_id: 1, title: 'New', noindex: true, evil_extra: 'ignored',
+    }, client as any);
+    expect(client.updateYoastSEO).toHaveBeenCalledWith(1, { title: 'New', noindex: true });
+  });
+
+  it('preserves null in noindex (tri-state)', async () => {
+    await handleYoastTool('yoast_update_seo', { post_id: 1, noindex: null }, client as any);
+    expect(client.updateYoastSEO).toHaveBeenCalledWith(1, { noindex: null });
+  });
+
+  it('filters robots_advanced to known directives only', async () => {
+    await handleYoastTool('yoast_update_seo', {
+      post_id: 1, robots_advanced: ['noarchive', 'evil', 'nosnippet'],
+    }, client as any);
+    expect(client.updateYoastSEO).toHaveBeenCalledWith(1, {
+      robots_advanced: ['noarchive', 'nosnippet'],
+    });
+  });
+
+  it('drops out-of-enum schema_page_type values', async () => {
+    await handleYoastTool('yoast_update_seo', {
+      post_id: 1, schema_page_type: 'BogusType', title: 'Valid',
+    }, client as any);
+    expect(client.updateYoastSEO).toHaveBeenCalledWith(1, { title: 'Valid' });
+  });
+
+  it('post_id is the first arg not part of the body', async () => {
+    await handleYoastTool('yoast_update_seo', { post_id: 99, title: 'X' }, client as any);
+    const [id, body] = client.updateYoastSEO.mock.calls[0] as [number, Record<string, unknown>];
+    expect(id).toBe(99);
+    expect(body).not.toHaveProperty('post_id');
+  });
+});
+
+describe('yoast_update_seo — response shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.updateYoastSEO.mockResolvedValue({ ...yoastSEOResponse, title: 'Updated' });
+    vi.clearAllMocks();
+  });
+
+  it('returns updated SEO metadata', async () => {
+    const result = await handleYoastTool('yoast_update_seo', { post_id: 1, title: 'Updated' }, client as any) as any;
+    expect(result.post_id).toBe(9999);
+    expect(result.title).toBe('Updated');
+  });
+});