@hailer/mcp 1.1.15 → 1.1.16

package/dist/plugins/vipunen/__tests__/tools.test.js

@@ -0,0 +1,646 @@
+"use strict";
+/**
+ * Vipunen Tools Tests
+ *
+ * Tests for Weaviate RAG knowledge base tools.
+ * Uses a mock WeaviateClient to test tool logic without a real Weaviate instance.
+ *
+ * Run with: MCP_CLIENT_API_KEY=test npx tsx --test src/plugins/vipunen/__tests__/tools.test.ts
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const client_1 = require("../client");
+const tools_1 = require("../tools");
+// ============================================================================
+// Mock WeaviateClient
+// ============================================================================
+function createMockClient() {
+    const responses = {};
+    const calls = {};
+    const trackCall = (method, ...args) => {
+        if (!calls[method])
+            calls[method] = [];
+        calls[method].push(args);
+        return responses[method] ?? null;
+    };
+    const mock = {
+        _calls: calls,
+        _setResponse: (method, response) => {
+            responses[method] = response;
+        },
+        hybridSearch: async (...args) => trackCall('hybridSearch', ...args),
+        nearTextSearch: async (...args) => trackCall('nearTextSearch', ...args),
+        aggregateGroupBy: async (...args) => trackCall('aggregateGroupBy', ...args),
+        insertObject: async (...args) => trackCall('insertObject', ...args),
+        deleteByProperty: async (...args) => trackCall('deleteByProperty', ...args),
+        deleteByMultipleProperties: async (...args) => trackCall('deleteByMultipleProperties', ...args),
+        batchDelete: async (...args) => trackCall('batchDelete', ...args),
+        getCollectionSchema: async (...args) => trackCall('getCollectionSchema', ...args),
+        graphql: async (...args) => trackCall('graphql', ...args),
+        filterQuery: async (...args) => trackCall('filterQuery', ...args),
+        exportCollection: async (...args) => trackCall('exportCollection', ...args),
+        batchInsert: async (...args) => trackCall('batchInsert', ...args),
+        createCollection: async (...args) => trackCall('createCollection', ...args),
+        deleteCollection: async (...args) => trackCall('deleteCollection', ...args),
+        countCollection: async (...args) => trackCall('countCollection', ...args),
+    };
+    return mock;
+}
+function getToolByName(tools, name) {
+    const tool = tools.find(t => t.name === name);
+    if (!tool)
+        throw new Error(`Tool ${name} not found. Available: ${tools.map(t => t.name).join(', ')}`);
+    return tool;
+}
+function parseResult(response) {
+    return JSON.parse(response.content[0].text);
+}
+// Context helpers
+const readonlyContext = { group: 'readonly' };
+const devContext = { group: 'dev' };
+const adminContext = { group: 'admin' };
+// ============================================================================
+// Tests
+// ============================================================================
+(0, node_test_1.describe)('Vipunen Tools', () => {
+    let mockClient;
+    let tools;
+    (0, node_test_1.beforeEach)(() => {
+        mockClient = createMockClient();
+    });
+    (0, node_test_1.describe)('Tool registration', () => {
+        (0, node_test_1.it)('creates 13 tools', () => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+            node_assert_1.default.strictEqual(tools.length, 13);
+            const names = tools.map(t => t.name);
+            node_assert_1.default.ok(names.includes('vipunen-query'));
+            node_assert_1.default.ok(names.includes('vipunen-insert-one'));
+            node_assert_1.default.ok(names.includes('vipunen-list-sources'));
+            node_assert_1.default.ok(names.includes('vipunen-find-similar'));
+            node_assert_1.default.ok(names.includes('vipunen-update-chunks'));
+            node_assert_1.default.ok(names.includes('vipunen-delete-source'));
+            node_assert_1.default.ok(names.includes('vipunen-count'));
+            node_assert_1.default.ok(names.includes('vipunen-filter'));
+            node_assert_1.default.ok(names.includes('vipunen-get-schema'));
+            node_assert_1.default.ok(names.includes('vipunen-export'));
+            node_assert_1.default.ok(names.includes('vipunen-batch-insert'));
+            node_assert_1.default.ok(names.includes('vipunen-create-collection'));
+            node_assert_1.default.ok(names.includes('vipunen-delete-collection'));
+        });
+        (0, node_test_1.it)('all tools have contextType none', () => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+            for (const tool of tools) {
+                node_assert_1.default.strictEqual(tool.contextType, 'none', `${tool.name} should have contextType 'none'`);
+            }
+        });
+    });
+    (0, node_test_1.describe)('vipunen-query', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('calls hybridSearch with correct args', async () => {
+            mockClient._setResponse('hybridSearch', {
+                objects: [
+                    { title: 'Test Doc', content: 'Hello', _score: 0.95, _id: 'abc' },
+                ],
+            });
+            const tool = getToolByName(tools, 'vipunen-query');
+            const result = await tool.execute({ collection: 'TestCol', query: 'test query', targetProperties: ['title', 'content'], limit: 3 }, readonlyContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.count, 1);
+            node_assert_1.default.strictEqual(data.objects[0].title, 'Test Doc');
+            // Verify call args
+            const callArgs = mockClient._calls.hybridSearch[0];
+            node_assert_1.default.strictEqual(callArgs[0], 'TestCol');
+            node_assert_1.default.strictEqual(callArgs[1], 'test query');
+            node_assert_1.default.deepStrictEqual(callArgs[2], ['title', 'content']);
+            node_assert_1.default.strictEqual(callArgs[3], 3);
+        });
+        (0, node_test_1.it)('passes limit through to client', async () => {
+            mockClient._setResponse('hybridSearch', { objects: [] });
+            const tool = getToolByName(tools, 'vipunen-query');
+            await tool.execute({ collection: 'TestCol', query: 'test', targetProperties: ['title'], limit: 5 }, readonlyContext);
+            const callArgs = mockClient._calls.hybridSearch[0];
+            node_assert_1.default.strictEqual(callArgs[3], 5);
+        });
+        (0, node_test_1.it)('returns error on failure', async () => {
+            mockClient.hybridSearch = async () => { throw new Error('Connection refused'); };
+            const tool = getToolByName(tools, 'vipunen-query');
+            const result = await tool.execute({ collection: 'TestCol', query: 'test', targetProperties: ['title'] }, readonlyContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('Connection refused'));
+        });
+        (0, node_test_1.it)('returns error on WeaviateAuthError', async () => {
+            mockClient.hybridSearch = async () => { throw new client_1.WeaviateAuthError(401); };
+            const tool = getToolByName(tools, 'vipunen-query');
+            const result = await tool.execute({ collection: 'TestCol', query: 'test', targetProperties: ['title'] }, readonlyContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('authentication failed'));
+        });
+        (0, node_test_1.it)('passes where filter through to hybridSearch', async () => {
+            mockClient._setResponse('hybridSearch', { objects: [] });
+            const tool = getToolByName(tools, 'vipunen-query');
+            const where = { path: ['scope'], operator: 'Equal', valueText: 'hailer-mcp' };
+            await tool.execute({ collection: 'TestCol', query: 'test', targetProperties: ['title'], limit: 5, where }, readonlyContext);
+            const callArgs = mockClient._calls.hybridSearch[0];
+            node_assert_1.default.strictEqual(callArgs[4].operator, 'Equal');
+            node_assert_1.default.deepStrictEqual(callArgs[4].path, ['scope']);
+            node_assert_1.default.strictEqual(callArgs[4].valueText, 'hailer-mcp');
+        });
+        (0, node_test_1.it)('passes compound where filter with operands', async () => {
+            mockClient._setResponse('hybridSearch', { objects: [] });
+            const tool = getToolByName(tools, 'vipunen-query');
+            const where = {
+                operator: 'And',
+                operands: [
+                    { path: ['scope'], operator: 'Equal', valueText: 'hailer-mcp' },
+                    { path: ['doc_type'], operator: 'Equal', valueText: 'reference' },
+                ],
+            };
+            await tool.execute({ collection: 'TestCol', query: 'test', targetProperties: ['title'], limit: 5, where }, readonlyContext);
+            const callArgs = mockClient._calls.hybridSearch[0];
+            node_assert_1.default.strictEqual(callArgs[4].operator, 'And');
+            node_assert_1.default.strictEqual(callArgs[4].operands.length, 2);
+        });
+        (0, node_test_1.it)('works without where filter (backward compat)', async () => {
+            mockClient._setResponse('hybridSearch', { objects: [] });
+            const tool = getToolByName(tools, 'vipunen-query');
+            await tool.execute({ collection: 'TestCol', query: 'test', targetProperties: ['title'], limit: 5 }, readonlyContext);
+            const callArgs = mockClient._calls.hybridSearch[0];
+            node_assert_1.default.strictEqual(callArgs[4], undefined);
+        });
+    });
+    (0, node_test_1.describe)('vipunen-insert-one', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('inserts object and returns uuid', async () => {
+            mockClient._setResponse('insertObject', { uuid: 'uuid-123' });
+            const tool = getToolByName(tools, 'vipunen-insert-one');
+            const result = await tool.execute({ collection: 'TestCol', properties: { title: 'New Doc', content: 'Body text' } }, devContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.uuid, 'uuid-123');
+            const callArgs = mockClient._calls.insertObject[0];
+            node_assert_1.default.strictEqual(callArgs[0], 'TestCol');
+            node_assert_1.default.strictEqual(callArgs[1].title, 'New Doc');
+        });
+    });
+    (0, node_test_1.describe)('vipunen-list-sources', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('returns aggregated source files', async () => {
+            mockClient._setResponse('aggregateGroupBy', [
+                { value: 'docs/api.md', count: 5 },
+                { value: 'docs/guide.md', count: 3 },
+            ]);
+            const tool = getToolByName(tools, 'vipunen-list-sources');
+            const result = await tool.execute({ collection: 'TestCol' }, readonlyContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.totalSources, 2);
+            node_assert_1.default.strictEqual(data.sources[0].source_file, 'docs/api.md');
+            node_assert_1.default.strictEqual(data.sources[0].chunk_count, 5);
+        });
+    });
+    (0, node_test_1.describe)('vipunen-find-similar', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('calls nearTextSearch', async () => {
+            mockClient._setResponse('nearTextSearch', {
+                objects: [
+                    { title: 'Similar Doc', _certainty: 0.92, _distance: 0.08, _id: 'xyz' },
+                ],
+            });
+            const tool = getToolByName(tools, 'vipunen-find-similar');
+            const result = await tool.execute({ collection: 'TestCol', query: 'find this', limit: 3 }, readonlyContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.count, 1);
+            node_assert_1.default.strictEqual(data.objects[0]._certainty, 0.92);
+            const callArgs = mockClient._calls.nearTextSearch[0];
+            node_assert_1.default.strictEqual(callArgs[0], 'TestCol');
+            node_assert_1.default.strictEqual(callArgs[1], 'find this');
+            node_assert_1.default.strictEqual(callArgs[2], 3);
+        });
+    });
+    (0, node_test_1.describe)('vipunen-update-chunks', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('deletes then inserts each chunk', async () => {
+            mockClient._setResponse('deleteByMultipleProperties', { matches: 1, successful: 1 });
+            mockClient._setResponse('insertObject', { uuid: 'new-uuid' });
+            const tool = getToolByName(tools, 'vipunen-update-chunks');
+            const result = await tool.execute({
+                collection: 'TestCol',
+                scope: 'hailer-mcp',
+                topic: 'overview',
+                chunks: [
+                    { chunk_index: 0, properties: { title: 'Updated chunk', content: 'New content' } },
+                    { chunk_index: 1, properties: { title: 'Chunk 2', content: 'More content' } },
+                ],
+            }, devContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.updated, 2);
+            // Should have called deleteByMultipleProperties twice
+            node_assert_1.default.strictEqual(mockClient._calls.deleteByMultipleProperties.length, 2);
+            // Should have called insertObject twice
+            node_assert_1.default.strictEqual(mockClient._calls.insertObject.length, 2);
+            // Verify scope/topic/chunk_index are baked into inserted properties
+            const insertedProps = mockClient._calls.insertObject[0][1];
+            node_assert_1.default.strictEqual(insertedProps.scope, 'hailer-mcp');
+            node_assert_1.default.strictEqual(insertedProps.topic, 'overview');
+            node_assert_1.default.strictEqual(insertedProps.chunk_index, 0);
+            node_assert_1.default.strictEqual(insertedProps.title, 'Updated chunk');
+            // Verify chunk_index is passed as number (not string) to deleteByMultipleProperties
+            const deleteConditions = mockClient._calls.deleteByMultipleProperties[0][1];
+            const chunkCondition = deleteConditions.find((c) => c.property === 'chunk_index');
+            node_assert_1.default.strictEqual(typeof chunkCondition.value, 'number');
+            node_assert_1.default.strictEqual(chunkCondition.value, 0);
+        });
+        (0, node_test_1.it)('continues if delete fails (chunk does not exist yet)', async () => {
+            mockClient.deleteByMultipleProperties = async () => { throw new Error('not found'); };
+            mockClient._setResponse('insertObject', { uuid: 'new-uuid' });
+            const tool = getToolByName(tools, 'vipunen-update-chunks');
+            const result = await tool.execute({
+                collection: 'TestCol',
+                scope: 'test',
+                topic: 'new-topic',
+                chunks: [{ chunk_index: 0, properties: { title: 'First chunk', content: 'Content' } }],
+            }, devContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.updated, 1);
+        });
+    });
+    (0, node_test_1.describe)('vipunen-delete-source', () => {
+        (0, node_test_1.it)('deletes by source_file', async () => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+            mockClient._setResponse('deleteByProperty', { matches: 5, successful: 5 });
+            const tool = getToolByName(tools, 'vipunen-delete-source');
+            const result = await tool.execute({ collection: 'TestCol', source_file: 'docs/old.md' }, devContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.deleted, 5);
+            node_assert_1.default.strictEqual(data.matched, 5);
+            const callArgs = mockClient._calls.deleteByProperty[0];
+            node_assert_1.default.strictEqual(callArgs[0], 'TestCol');
+            node_assert_1.default.strictEqual(callArgs[1], 'source_file');
+            node_assert_1.default.strictEqual(callArgs[2], 'docs/old.md');
+        });
+    });
+    // --------------------------------------------------------------------------
+    // New tools
+    // --------------------------------------------------------------------------
+    (0, node_test_1.describe)('vipunen-count', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('returns count from aggregate query', async () => {
+            mockClient._setResponse('countCollection', 42);
+            const tool = getToolByName(tools, 'vipunen-count');
+            const result = await tool.execute({ collection: 'TestCol' }, readonlyContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.collection, 'TestCol');
+            node_assert_1.default.strictEqual(data.count, 42);
+        });
+    });
+    (0, node_test_1.describe)('vipunen-filter', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('passes where filter to filterQuery', async () => {
+            mockClient._setResponse('filterQuery', {
+                objects: [{ title: 'Match', _id: 'abc' }],
+            });
+            const tool = getToolByName(tools, 'vipunen-filter');
+            const where = { path: ['scope'], operator: 'Equal', valueText: 'hailer-mcp' };
+            const result = await tool.execute({ collection: 'TestCol', where, limit: 10 }, readonlyContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.count, 1);
+            node_assert_1.default.strictEqual(data.objects[0].title, 'Match');
+            const callArgs = mockClient._calls.filterQuery[0];
+            node_assert_1.default.strictEqual(callArgs[0], 'TestCol');
+            node_assert_1.default.deepStrictEqual(callArgs[1], where);
+        });
+    });
+    (0, node_test_1.describe)('vipunen-get-schema (admin only)', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('returns schema for admin', async () => {
+            mockClient._setResponse('getCollectionSchema', {
+                class: 'TestCol',
+                properties: [{ name: 'title', dataType: ['text'] }],
+            });
+            const tool = getToolByName(tools, 'vipunen-get-schema');
+            const result = await tool.execute({ collection: 'TestCol' }, adminContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.class, 'TestCol');
+            node_assert_1.default.strictEqual(data.properties[0].name, 'title');
+        });
+        (0, node_test_1.it)('rejects readonly group', async () => {
+            const tool = getToolByName(tools, 'vipunen-get-schema');
+            const result = await tool.execute({ collection: 'TestCol' }, readonlyContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('Admin access required'));
+        });
+        (0, node_test_1.it)('rejects dev group', async () => {
+            const tool = getToolByName(tools, 'vipunen-get-schema');
+            const result = await tool.execute({ collection: 'TestCol' }, devContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('Admin access required'));
+        });
+    });
+    (0, node_test_1.describe)('vipunen-export (admin only)', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('returns exported objects for admin', async () => {
+            mockClient._setResponse('exportCollection', {
+                objects: [{ title: 'Doc 1', _id: 'a' }, { title: 'Doc 2', _id: 'b' }],
+                totalCount: 2,
+            });
+            const tool = getToolByName(tools, 'vipunen-export');
+            const result = await tool.execute({ collection: 'TestCol', pageSize: 50 }, adminContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.collection, 'TestCol');
+            node_assert_1.default.strictEqual(data.count, 2);
+            node_assert_1.default.strictEqual(data.objects.length, 2);
+        });
+        (0, node_test_1.it)('rejects readonly group', async () => {
+            const tool = getToolByName(tools, 'vipunen-export');
+            const result = await tool.execute({ collection: 'TestCol' }, readonlyContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('Admin access required'));
+        });
+    });
+    (0, node_test_1.describe)('vipunen-batch-insert (admin only)', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('batch inserts objects for admin', async () => {
+            mockClient._setResponse('batchInsert', {
+                inserted: 3,
+                errors: 0,
+                errorDetails: [],
+            });
+            const tool = getToolByName(tools, 'vipunen-batch-insert');
+            const result = await tool.execute({
+                collection: 'TestCol',
+                objects: [
+                    { title: 'A', content: '1' },
+                    { title: 'B', content: '2' },
+                    { title: 'C', content: '3' },
+                ],
+                batchSize: 20,
+            }, adminContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.inserted, 3);
+            node_assert_1.default.strictEqual(data.errors, 0);
+        });
+        (0, node_test_1.it)('rejects dev group', async () => {
+            const tool = getToolByName(tools, 'vipunen-batch-insert');
+            const result = await tool.execute({ collection: 'TestCol', objects: [{ title: 'A' }] }, devContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('Admin access required'));
+        });
+    });
+    (0, node_test_1.describe)('vipunen-create-collection (admin only)', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('creates collection for admin', async () => {
+            mockClient._setResponse('createCollection', { created: true, objectCount: 0 });
+            const tool = getToolByName(tools, 'vipunen-create-collection');
+            const result = await tool.execute({ collection: 'NewCol', schema: 'doc' }, adminContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.collection, 'NewCol');
+            node_assert_1.default.strictEqual(data.created, true);
+            node_assert_1.default.strictEqual(data.objectCount, 0);
+        });
+        (0, node_test_1.it)('returns existing for idempotent call', async () => {
+            mockClient._setResponse('createCollection', { created: false, objectCount: 42 });
+            const tool = getToolByName(tools, 'vipunen-create-collection');
+            const result = await tool.execute({ collection: 'ExistingCol', schema: 'doc' }, adminContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.created, false);
+            node_assert_1.default.strictEqual(data.objectCount, 42);
+        });
+        (0, node_test_1.it)('rejects readonly group', async () => {
+            const tool = getToolByName(tools, 'vipunen-create-collection');
+            const result = await tool.execute({ collection: 'NewCol', schema: 'doc' }, readonlyContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('Admin access required'));
+        });
+    });
+    (0, node_test_1.describe)('vipunen-delete-collection (admin only)', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('deletes collection for admin', async () => {
+            mockClient._setResponse('deleteCollection', { deleted: true });
+            const tool = getToolByName(tools, 'vipunen-delete-collection');
+            const result = await tool.execute({ collection: 'OldCol' }, adminContext);
+            const data = parseResult(result);
+            node_assert_1.default.strictEqual(data.collection, 'OldCol');
+            node_assert_1.default.strictEqual(data.deleted, true);
+        });
+        (0, node_test_1.it)('rejects dev group', async () => {
+            const tool = getToolByName(tools, 'vipunen-delete-collection');
+            const result = await tool.execute({ collection: 'OldCol' }, devContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('Admin access required'));
+        });
+    });
+    // --------------------------------------------------------------------------
+    // Permission model tests
+    // --------------------------------------------------------------------------
+    (0, node_test_1.describe)('Permission model', () => {
+        (0, node_test_1.beforeEach)(() => {
+            tools = (0, tools_1.createVipunenTools)(mockClient);
+        });
+        (0, node_test_1.it)('readonly can access read tools', async () => {
+            mockClient._setResponse('hybridSearch', { objects: [] });
+            mockClient._setResponse('nearTextSearch', { objects: [] });
+            mockClient._setResponse('aggregateGroupBy', []);
+            mockClient._setResponse('countCollection', 0);
+            mockClient._setResponse('filterQuery', { objects: [] });
+            const readTools = ['vipunen-query', 'vipunen-find-similar', 'vipunen-list-sources', 'vipunen-count', 'vipunen-filter'];
+            for (const name of readTools) {
+                const tool = getToolByName(tools, name);
+                let args = { collection: 'TestCol' };
+                if (name === 'vipunen-query')
+                    args = { ...args, query: 'test', targetProperties: ['title'], limit: 5 };
+                if (name === 'vipunen-find-similar')
+                    args = { ...args, query: 'test', limit: 5 };
+                if (name === 'vipunen-filter')
+                    args = { ...args, where: { path: ['scope'], operator: 'Equal', valueText: 'test' } };
+                const result = await tool.execute(args, readonlyContext);
+                node_assert_1.default.strictEqual(result.isError, undefined, `${name} should succeed for readonly`);
+            }
+        });
+        (0, node_test_1.it)('readonly cannot access write tools', async () => {
+            const writeTools = ['vipunen-insert-one', 'vipunen-update-chunks', 'vipunen-delete-source'];
+            for (const name of writeTools) {
+                const tool = getToolByName(tools, name);
+                let args = { collection: 'TestCol' };
+                if (name === 'vipunen-insert-one')
+                    args = { ...args, properties: { title: 'x' } };
+                if (name === 'vipunen-update-chunks')
+                    args = { ...args, scope: 's', topic: 't', chunks: [] };
+                if (name === 'vipunen-delete-source')
+                    args = { ...args, source_file: 'x' };
+                const result = await tool.execute(args, readonlyContext);
+                node_assert_1.default.strictEqual(result.isError, true, `${name} should fail for readonly`);
+            }
+        });
+        (0, node_test_1.it)('dev cannot write to VipunenConfig', async () => {
+            const tool = getToolByName(tools, 'vipunen-insert-one');
+            const result = await tool.execute({ collection: 'VipunenConfig', properties: { title: 'x' } }, devContext);
+            node_assert_1.default.strictEqual(result.isError, true);
+            const data = parseResult(result);
+            node_assert_1.default.ok(data.error.includes('VipunenConfig'));
+        });
+        (0, node_test_1.it)('dev cannot access admin tools', async () => {
+            const adminTools = ['vipunen-get-schema', 'vipunen-export', 'vipunen-batch-insert', 'vipunen-create-collection', 'vipunen-delete-collection'];
+            for (const name of adminTools) {
+                const tool = getToolByName(tools, name);
+                let args = { collection: 'TestCol' };
+                if (name === 'vipunen-batch-insert')
+                    args = { ...args, objects: [] };
+                if (name === 'vipunen-create-collection')
+                    args = { ...args, schema: 'doc' };
+                const result = await tool.execute(args, devContext);
+                node_assert_1.default.strictEqual(result.isError, true, `${name} should fail for dev`);
+            }
+        });
+    });
+});
+(0, node_test_1.describe)('WeaviateClient', () => {
+    (0, node_test_1.describe)('constructor', () => {
+        (0, node_test_1.it)('strips trailing slash from host', () => {
+            const client = new client_1.WeaviateClient({ host: 'http://localhost:8080/' });
+            node_assert_1.default.strictEqual(client.host, 'http://localhost:8080');
+        });
+        (0, node_test_1.it)('sets auth header when apiKey provided', () => {
+            const client = new client_1.WeaviateClient({ host: 'http://localhost:8080', apiKey: 'test-key' });
+            node_assert_1.default.strictEqual(client.headers['Authorization'], 'Bearer test-key');
+        });
+        (0, node_test_1.it)('omits auth header when no apiKey', () => {
+            const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+            node_assert_1.default.strictEqual(client.headers['Authorization'], undefined);
+        });
+    });
+    (0, node_test_1.describe)('escapeGraphQL', () => {
+        (0, node_test_1.it)('escapes quotes and newlines', () => {
+            const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+            const escaped = client.escapeGraphQL('test "quoted"\nnewline');
+            node_assert_1.default.strictEqual(escaped, 'test \\"quoted\\"\\nnewline');
+        });
+    });
+    (0, node_test_1.describe)('input validation', () => {
+        (0, node_test_1.it)('rejects invalid collection names', () => {
+            const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+            node_assert_1.default.throws(() => client.validateCollectionName('invalid-name'), /Invalid collection name/);
+            node_assert_1.default.throws(() => client.validateCollectionName('lowercase'), /Invalid collection name/);
+            node_assert_1.default.throws(() => client.validateCollectionName('Has Space'), /Invalid collection name/);
+            // Valid names should not throw
+            client.validateCollectionName('InternalDev');
+            client.validateCollectionName('TestCol');
+        });
+        (0, node_test_1.it)('rejects invalid property names', () => {
+            const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+            node_assert_1.default.throws(() => client.validatePropertyNames(['valid', 'has space']), /Invalid property name/);
+            node_assert_1.default.throws(() => client.validatePropertyNames(['123starts_with_number']), /Invalid property name/);
+            // Valid names should not throw
+            client.validatePropertyNames(['title', 'content', '_score', 'doc_type']);
+        });
+    });
+});
+(0, node_test_1.describe)('WeaviateAuthError', () => {
+    (0, node_test_1.it)('has correct name and status', () => {
+        const error = new client_1.WeaviateAuthError(401);
+        node_assert_1.default.strictEqual(error.name, 'WeaviateAuthError');
+        node_assert_1.default.strictEqual(error.status, 401);
+        node_assert_1.default.ok(error.message.includes('401'));
+    });
+});
+(0, node_test_1.describe)('WeaviateClient.serializeWhereFilter', () => {
+    (0, node_test_1.it)('serializes a simple Equal filter', () => {
+        const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+        const result = client.serializeWhereFilter({
+            path: ['scope'],
+            operator: 'Equal',
+            valueText: 'hailer-mcp',
+        });
+        node_assert_1.default.ok(result.includes('operator: Equal'));
+        node_assert_1.default.ok(result.includes('path: ["scope"]'));
+        node_assert_1.default.ok(result.includes('valueText: "hailer-mcp"'));
+    });
+    (0, node_test_1.it)('serializes compound And filter with operands', () => {
+        const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+        const result = client.serializeWhereFilter({
+            operator: 'And',
+            operands: [
+                { path: ['scope'], operator: 'Equal', valueText: 'hailer-mcp' },
+                { path: ['doc_type'], operator: 'Equal', valueText: 'reference' },
+            ],
+        });
+        node_assert_1.default.ok(result.includes('operator: And'));
+        node_assert_1.default.ok(result.includes('operands: ['));
+        node_assert_1.default.ok(result.includes('valueText: "hailer-mcp"'));
+        node_assert_1.default.ok(result.includes('valueText: "reference"'));
+    });
+    (0, node_test_1.it)('serializes valueInt and valueBoolean', () => {
+        const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+        const intResult = client.serializeWhereFilter({
+            path: ['chunk_index'],
+            operator: 'Equal',
+            valueInt: 3,
+        });
+        node_assert_1.default.ok(intResult.includes('valueInt: 3'));
+        const boolResult = client.serializeWhereFilter({
+            path: ['verified'],
+            operator: 'Equal',
+            valueBoolean: true,
+        });
+        node_assert_1.default.ok(boolResult.includes('valueBoolean: true'));
+    });
+    (0, node_test_1.it)('rejects invalid operator', () => {
+        const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+        node_assert_1.default.throws(() => client.serializeWhereFilter({
+            path: ['scope'],
+            operator: 'DROP TABLE',
+            valueText: 'evil',
+        }), /Invalid where operator/);
+    });
+    (0, node_test_1.it)('rejects invalid path names', () => {
+        const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+        node_assert_1.default.throws(() => client.serializeWhereFilter({
+            path: ['has space'],
+            operator: 'Equal',
+            valueText: 'test',
+        }), /Invalid property name/);
+    });
+    (0, node_test_1.it)('escapes special characters in valueText', () => {
+        const client = new client_1.WeaviateClient({ host: 'http://localhost:8080' });
+        const result = client.serializeWhereFilter({
+            path: ['title'],
+            operator: 'Like',
+            valueText: 'test "quoted" value',
+        });
+        node_assert_1.default.ok(result.includes('test \\"quoted\\" value'));
+    });
+});
+//# sourceMappingURL=tools.test.js.map