@gravitykit/block-mcp 2.0.0-beta

package/src/__tests__/tools/discovery/list_patterns.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Tool tests: list_patterns
+ *
+ * Covers:
+ *   - Filter forwarding (search → q, synced, min_score)
+ *   - Server-side limit = offset + limit (so client slice still works)
+ *   - Client-side slicing via offset
+ *   - Defaults: limit 20, offset 0
+ *   - Response shape: patterns, count, total, offset, next_offset, summary
+ *   - Enrichment via enrichPatternList (summary is present)
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { handleDiscoveryTool } from '../../../tools/discovery.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+import { patternsResponse } from '../../fixtures/rest-responses.js';
+
+describe('list_patterns — filter forwarding', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.getPatterns.mockResolvedValue(patternsResponse);
+  });
+
+  it('forwards search as q and other filters', async () => {
+    await handleDiscoveryTool('list_patterns', {
+      search: 'hero', synced: true, min_score: 50,
+    }, client as any);
+    expect(client.getPatterns).toHaveBeenCalledWith(expect.objectContaining({
+      q: 'hero', synced: true, min_score: 50,
+    }));
+  });
+
+  it('forwards no filters when none are provided', async () => {
+    await handleDiscoveryTool('list_patterns', {}, client as any);
+    expect(client.getPatterns).toHaveBeenCalledWith(expect.objectContaining({
+      q: undefined, synced: undefined, min_score: undefined,
+    }));
+  });
+});
+
+describe('list_patterns — pagination', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.getPatterns.mockResolvedValue(patternsResponse);
+  });
+
+  it('defaults to limit 20, offset 0', async () => {
+    await handleDiscoveryTool('list_patterns', {}, client as any);
+    // server limit is offset + limit = 0 + 20 = 20
+    expect(client.getPatterns).toHaveBeenCalledWith(expect.objectContaining({ limit: 20 }));
+  });
+
+  it('server limit accounts for offset (offset+limit)', async () => {
+    await handleDiscoveryTool('list_patterns', { limit: 10, offset: 30 }, client as any);
+    expect(client.getPatterns).toHaveBeenCalledWith(expect.objectContaining({ limit: 40 }));
+  });
+
+  it('client-side slice honors offset', async () => {
+    const many = Array.from({ length: 30 }, (_, i) => ({
+      id: i + 1, name: `pattern-${i}`,
+      type: 'synced' as const,
+      created: '2026-01-01', modified: '2026-01-01',
+      reference_count: 0,
+      preference: { score: 50 - i, tier: 'recommended' as const, reasons: [] },
+      contains_blocks: [], has_legacy_blocks: false,
+    }));
+    client.getPatterns.mockResolvedValueOnce({ patterns: many } as any);
+    const result = await handleDiscoveryTool('list_patterns', { limit: 5, offset: 10 }, client as any) as Record<string, unknown>;
+    expect((result.patterns as unknown[]).length).toBe(5);
+    expect(result.offset).toBe(10);
+  });
+
+  it('next_offset is null at end of results', async () => {
+    const five = Array.from({ length: 5 }, (_, i) => ({
+      id: i + 1, name: `p-${i}`,
+      type: 'synced' as const,
+      created: '2026-01-01', modified: '2026-01-01',
+      reference_count: 0,
+      preference: { score: 50, tier: 'recommended' as const, reasons: [] },
+      contains_blocks: [], has_legacy_blocks: false,
+    }));
+    client.getPatterns.mockResolvedValueOnce({ patterns: five } as any);
+    const result = await handleDiscoveryTool('list_patterns', { limit: 10 }, client as any) as Record<string, unknown>;
+    expect(result.next_offset).toBeNull();
+  });
+});
+
+describe('list_patterns — response shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.getPatterns.mockResolvedValue(patternsResponse);
+  });
+
+  it('returns patterns, count, total, offset, next_offset, summary', async () => {
+    const result = await handleDiscoveryTool('list_patterns', {}, client as any) as Record<string, unknown>;
+    expect(Array.isArray(result.patterns)).toBe(true);
+    expect(typeof result.count).toBe('number');
+    expect(typeof result.total).toBe('number');
+    expect(typeof result.offset).toBe('number');
+    // summary is created by enrichPatternList — may be a string or structured value
+    expect(result.summary).toBeDefined();
+  });
+});

package/src/__tests__/tools/discovery/list_posts.test.ts

@@ -0,0 +1,47 @@
+/**
+ * Tool tests: list_posts
+ *
+ * Covers:
+ *   - Forwards all filters verbatim (search, post_type, post_status,
+ *     per_page, page)
+ *   - All undefined when args is empty
+ *   - Returns raw client response
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { handleDiscoveryTool } from '../../../tools/discovery.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+
+describe('list_posts', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.findPosts.mockResolvedValue({
+      posts: [{ post_id: 1, title: 'Hello', slug: 'hello', post_type: 'post', post_status: 'publish', post_url: 'x', modified: '2026-01-01' }],
+      total: 1, page: 1, per_page: 20, total_pages: 1,
+    } as any);
+  });
+
+  it('forwards all filters', async () => {
+    await handleDiscoveryTool('list_posts', {
+      search: 'foo', post_type: 'page', post_status: 'draft', per_page: 50, page: 2,
+    }, client as any);
+    expect(client.findPosts).toHaveBeenCalledWith({
+      search: 'foo', post_type: 'page', post_status: 'draft', per_page: 50, page: 2,
+    });
+  });
+
+  it('passes undefineds when args is empty', async () => {
+    await handleDiscoveryTool('list_posts', {}, client as any);
+    expect(client.findPosts).toHaveBeenCalledWith({
+      search: undefined, post_type: undefined, post_status: undefined,
+      per_page: undefined, page: undefined,
+    });
+  });
+
+  it('returns the raw client response', async () => {
+    const result = await handleDiscoveryTool('list_posts', {}, client as any) as Record<string, unknown>;
+    expect(Array.isArray(result.posts)).toBe(true);
+    expect(result.total).toBe(1);
+  });
+});

package/src/__tests__/tools/discovery/resolve_url.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Tool tests: resolve_url
+ *
+ * Covers:
+ *   - Requires non-empty string url
+ *   - Rejects missing/null/empty/non-string url
+ *   - Forwards url verbatim
+ *   - Returns raw client response
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { handleDiscoveryTool } from '../../../tools/discovery.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+import { resolveUrlResponse } from '../../fixtures/rest-responses.js';
+
+describe('resolve_url — validation', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.resolveUrl.mockResolvedValue(resolveUrlResponse);
+  });
+
+  it('rejects missing url', async () => {
+    await expect(
+      handleDiscoveryTool('resolve_url', {}, client as any)
+    ).rejects.toThrow(/url is required/);
+  });
+
+  it('rejects empty-string url', async () => {
+    await expect(
+      handleDiscoveryTool('resolve_url', { url: '' }, client as any)
+    ).rejects.toThrow(/url is required/);
+  });
+
+  it('rejects non-string url', async () => {
+    await expect(
+      handleDiscoveryTool('resolve_url', { url: 123 }, client as any)
+    ).rejects.toThrow(/url is required/);
+  });
+
+  it('rejects null url', async () => {
+    await expect(
+      handleDiscoveryTool('resolve_url', { url: null }, client as any)
+    ).rejects.toThrow(/url is required/);
+  });
+});
+
+describe('resolve_url — forwarding', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.resolveUrl.mockResolvedValue(resolveUrlResponse);
+  });
+
+  it('forwards a full URL', async () => {
+    await handleDiscoveryTool('resolve_url', { url: 'https://example.test/about/' }, client as any);
+    expect(client.resolveUrl).toHaveBeenCalledWith('https://example.test/about/');
+  });
+
+  it('forwards a relative path', async () => {
+    await handleDiscoveryTool('resolve_url', { url: '/about/' }, client as any);
+    expect(client.resolveUrl).toHaveBeenCalledWith('/about/');
+  });
+
+  it('returns the raw client response', async () => {
+    const result = await handleDiscoveryTool('resolve_url', { url: '/x' }, client as any);
+    expect(result).toBe(resolveUrlResponse);
+  });
+});

package/src/__tests__/tools/discovery/scan_storage_modes.test.ts

@@ -0,0 +1,34 @@
+/**
+ * Tool tests: scan_storage_modes
+ *
+ * Covers:
+ *   - Forwards to client.scanStorageModes with no args
+ *   - Returns the raw response (no MCP-side processing)
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { handleDiscoveryTool } from '../../../tools/discovery.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+
+describe('scan_storage_modes', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    client.scanStorageModes.mockResolvedValue({
+      scanned_posts: 100, unique_blocks: 25,
+      classification: { 'core/paragraph': 'static', 'core/latest-posts': 'dynamic' },
+      dual_count: 0, dynamic_count: 1, static_count: 24,
+    } as any);
+  });
+
+  it('calls client.scanStorageModes with no arguments', async () => {
+    await handleDiscoveryTool('scan_storage_modes', {}, client as any);
+    expect(client.scanStorageModes).toHaveBeenCalledWith();
+  });
+
+  it('returns the raw scan result', async () => {
+    const result = await handleDiscoveryTool('scan_storage_modes', {}, client as any) as Record<string, unknown>;
+    expect(result.scanned_posts).toBe(100);
+    expect(result.unique_blocks).toBe(25);
+  });
+});

package/src/__tests__/tools/media/upload_media.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Tool tests: upload_media
+ *
+ * Covers:
+ *   - Schema: upload_media exposed
+ *   - Validation: exactly one input mode (path, url, data_base64)
+ *   - Validation: data_base64 requires filename
+ *   - Request shape: url upload forwarded
+ *   - Request shape: base64 upload forwarded
+ *   - Request shape: path upload forwarded
+ *   - Optional fields (alt_text, post_id) forwarded with url mode
+ *   - Response shape: id, url, mime_type present
+ *   - Unknown tool throws
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MEDIA_TOOLS, handleMediaTool } from '../../../tools/media.js';
+import { makeMockClient } from '../../helpers/mock-client.js';
+
+describe('upload_media — schema', () => {
+  it('exposes upload_media tool', () => {
+    expect(MEDIA_TOOLS.map((t) => t.name)).toContain('upload_media');
+  });
+});
+
+describe('upload_media — validation', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); vi.clearAllMocks(); });
+
+  it('rejects when no input mode is provided', async () => {
+    await expect(handleMediaTool('upload_media', { alt_text: 'x' }, client as any))
+      .rejects.toThrow(/path.*url.*data_base64/);
+    expect(client.uploadMedia).not.toHaveBeenCalled();
+  });
+
+  it('rejects when multiple input modes are provided (path + url)', async () => {
+    await expect(handleMediaTool('upload_media', {
+      path: '/a.png', url: 'https://example.com/x.png',
+    }, client as any)).rejects.toThrow('only one of');
+    expect(client.uploadMedia).not.toHaveBeenCalled();
+  });
+
+  it('rejects when multiple input modes are provided (url + data_base64)', async () => {
+    await expect(handleMediaTool('upload_media', {
+      url: 'https://example.com/x.png', data_base64: 'aGVsbG8=', filename: 'x.png',
+    }, client as any)).rejects.toThrow('only one of');
+    expect(client.uploadMedia).not.toHaveBeenCalled();
+  });
+
+  it('rejects data_base64 without filename', async () => {
+    await expect(handleMediaTool('upload_media', { data_base64: 'aGVsbG8=' }, client as any))
+      .rejects.toThrow('filename');
+    expect(client.uploadMedia).not.toHaveBeenCalled();
+  });
+});
+
+describe('upload_media — request shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    vi.clearAllMocks();
+  });
+
+  it('forwards url upload to client', async () => {
+    await handleMediaTool('upload_media', { url: 'https://example.com/img.png' }, client as any);
+    expect(client.uploadMedia).toHaveBeenCalledWith({ url: 'https://example.com/img.png' });
+  });
+
+  it('forwards url upload with optional alt_text and post_id', async () => {
+    await handleMediaTool('upload_media', {
+      url: 'https://example.com/img.png', alt_text: 'hero image', post_id: 7,
+    }, client as any);
+    expect(client.uploadMedia).toHaveBeenCalledWith({
+      url: 'https://example.com/img.png', alt_text: 'hero image', post_id: 7,
+    });
+  });
+
+  it('forwards base64 upload with filename', async () => {
+    await handleMediaTool('upload_media', {
+      data_base64: 'aGVsbG8=', filename: 'hello.png',
+    }, client as any);
+    expect(client.uploadMedia).toHaveBeenCalledWith({
+      data_base64: 'aGVsbG8=', filename: 'hello.png',
+    });
+  });
+
+  it('forwards path upload', async () => {
+    await handleMediaTool('upload_media', { path: '/tmp/photo.jpg' }, client as any);
+    expect(client.uploadMedia).toHaveBeenCalledWith({ path: '/tmp/photo.jpg' });
+  });
+});
+
+describe('upload_media — response shape', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => {
+    client = makeMockClient();
+    vi.clearAllMocks();
+  });
+
+  it('returns success, id, url, mime_type', async () => {
+    const result = await handleMediaTool('upload_media', { url: 'https://example.com/x.png' }, client as any) as any;
+    expect(result.success).toBe(true);
+    expect(result.id).toBe(1);
+    expect(result.url).toBeDefined();
+    expect(result.mime_type).toBe('image/png');
+  });
+
+  it('returns filename and alt_text', async () => {
+    const result = await handleMediaTool('upload_media', { path: '/tmp/x.png' }, client as any) as any;
+    expect(result.filename).toBeDefined();
+    expect(typeof result.alt_text).toBe('string');
+  });
+});
+
+describe('upload_media — unknown tool', () => {
+  let client: ReturnType<typeof makeMockClient>;
+  beforeEach(() => { client = makeMockClient(); });
+
+  it('throws on unknown tool name', async () => {
+    await expect(handleMediaTool('unknown_tool', {}, client as any))
+      .rejects.toThrow('Unknown media tool');
+  });
+});