@maxisoft/instantcms-mcp 1.2.3

package/dist/__tests__/hooks-tool.test.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fc = __importStar(require("fast-check"));
+const hooks_tool_js_1 = require("../tools/hooks-tool.js");
+describe('hooks-tool knowledge lookups', () => {
+    describe('listHooks', () => {
+        test('возвращает структуру с total и hooks', () => {
+            const result = (0, hooks_tool_js_1.listHooks)();
+            expect(typeof result.total).toBe('number');
+            expect(result.total).toBeGreaterThan(0);
+            expect(Array.isArray(result.hooks)).toBe(true);
+            expect(Array.isArray(result.categories)).toBe(true);
+        });
+        test('фильтр по category оставляет только эту категорию', () => {
+            const result = (0, hooks_tool_js_1.listHooks)('content');
+            for (const hook of result.hooks) {
+                expect(hook.category).toBe('content');
+            }
+        });
+        test('фильтр по type оставляет только этот type (или содержит подстроку)', () => {
+            const result = (0, hooks_tool_js_1.listHooks)(undefined, 'filter');
+            for (const hook of result.hooks) {
+                expect(hook.type === 'filter' || hook.type.includes('filter')).toBe(true);
+            }
+        });
+        test('пагинация через cursor работает', () => {
+            const first = (0, hooks_tool_js_1.listHooks)(undefined, undefined, { limit: 5 });
+            expect(first.hooks).toHaveLength(5);
+            expect(first.page.returned).toBe(5);
+            expect(first.page.next_cursor).toBeTruthy();
+            const second = (0, hooks_tool_js_1.listHooks)(undefined, undefined, {
+                limit: 5,
+                cursor: first.page.next_cursor,
+            });
+            expect(second.hooks).toHaveLength(5);
+            const names = new Set([...first.hooks.map(h => h.name), ...second.hooks.map(h => h.name)]);
+            expect(names.size).toBe(10);
+        });
+        test('несуществующая категория → пустой результат', () => {
+            const result = (0, hooks_tool_js_1.listHooks)('this-category-does-not-exist');
+            expect(result.hooks).toHaveLength(0);
+            expect(result.total).toBe(0);
+        });
+        test('hook items всегда содержат name, type, category, parameters_count, return_type', () => {
+            const result = (0, hooks_tool_js_1.listHooks)(undefined, undefined, { limit: 100 });
+            for (const h of result.hooks) {
+                expect(typeof h.name).toBe('string');
+                expect(typeof h.type).toBe('string');
+                expect(typeof h.category).toBe('string');
+                expect(typeof h.parameters_count).toBe('number');
+            }
+        });
+    });
+    describe('getHookDetails', () => {
+        test('известный хук возвращает полную структуру', () => {
+            const candidates = ['content_after_add_approve', 'user_registered', 'admin_login'];
+            let resolved = null;
+            for (const name of candidates) {
+                const r = (0, hooks_tool_js_1.getHookDetails)(name);
+                if (!r.code && r.name === name) {
+                    resolved = name;
+                    break;
+                }
+            }
+            if (!resolved)
+                return; // ни один из тестовых имён не существует в базе
+            const result = (0, hooks_tool_js_1.getHookDetails)(resolved);
+            expect(result.name).toBe(resolved);
+            expect(result.implementation.class_name).toContain('on{AddonName}');
+            expect(result.implementation.file_path).toContain(resolved);
+            expect(result.manifest_xml).toContain(`name="${resolved}"`);
+        });
+        test('точный case-insensitive поиск', () => {
+            const first = (0, hooks_tool_js_1.listHooks)(undefined, undefined, { limit: 1 });
+            const realName = first.hooks[0].name;
+            const upper = (0, hooks_tool_js_1.getHookDetails)(realName.toUpperCase());
+            // Зависит от того, есть ли такой хук; если точный — должен найтись.
+            if (!upper.code) {
+                expect(upper.name).toBe(realName);
+            }
+        });
+        test('частичное совпадение → возвращает AMBIGUOUS_HOOK или null без произвольного выбора', () => {
+            const result = (0, hooks_tool_js_1.getHookDetails)('content');
+            // Если совпало несколько — должны быть перечислены все кандидаты.
+            if (result.code === 'AMBIGUOUS_HOOK') {
+                expect(Array.isArray(result.candidates)).toBe(true);
+                expect(result.candidates.length).toBeGreaterThan(1);
+            }
+            else {
+                // Если один или ноль — должен быть name или HOOK_NOT_FOUND.
+                expect(['name', 'code']).toContain(Object.keys(result)[0]);
+            }
+        });
+        test('несуществующий хук → HOOK_NOT_FOUND с similar_hooks', () => {
+            const result = (0, hooks_tool_js_1.getHookDetails)('nonexistent_hook_xyzqwerty');
+            expect(result.code).toBe('HOOK_NOT_FOUND');
+            expect(Array.isArray(result.similar_hooks)).toBe(true);
+        });
+    });
+    describe('searchHooks', () => {
+        test('поиск по имени', () => {
+            const candidates = (0, hooks_tool_js_1.listHooks)(undefined, undefined, { limit: 3 });
+            const someName = candidates.hooks[0].name;
+            const part = someName.split('_')[0];
+            const result = (0, hooks_tool_js_1.searchHooks)(part);
+            expect(result.total).toBeGreaterThan(0);
+            expect(result.results.some(h => h.name.includes(part))).toBe(true);
+        });
+        test('поиск по описанию (case-insensitive)', () => {
+            const result = (0, hooks_tool_js_1.searchHooks)('событие');
+            expect(result.total).toBeGreaterThanOrEqual(0);
+            // Если есть совпадения — проверяем структуру.
+            for (const r of result.results) {
+                expect(typeof r.name).toBe('string');
+                expect(typeof r.type).toBe('string');
+                expect(typeof r.category).toBe('string');
+            }
+        });
+        test('уникальные результаты (no duplicates)', () => {
+            const list = (0, hooks_tool_js_1.listHooks)(undefined, undefined, { limit: 10 });
+            const someName = list.hooks[0].name;
+            const result = (0, hooks_tool_js_1.searchHooks)(someName);
+            const names = result.results.map(r => r.name);
+            expect(new Set(names).size).toBe(names.length);
+        });
+        test('пустой запрос → 0 результатов', () => {
+            const result = (0, hooks_tool_js_1.searchHooks)('zzz_nonexistent_xyzqwerty_abc_999');
+            expect(result.total).toBe(0);
+            expect(result.results).toHaveLength(0);
+        });
+        test('property-based: search для произвольных строк не выбрасывает', () => {
+            fc.assert(fc.property(fc.string({ minLength: 0, maxLength: 100 }), query => {
+                const result = (0, hooks_tool_js_1.searchHooks)(query);
+                expect(Array.isArray(result.results)).toBe(true);
+                expect(typeof result.total).toBe('number');
+                return true;
+            }), { numRuns: 30 });
+        });
+    });
+});

package/dist/__tests__/mcp-integration-extra.test.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const inMemory_js_1 = require("@modelcontextprotocol/sdk/inMemory.js");
+const server_js_1 = require("../server.js");
+const schemas_js_1 = require("../data/schemas.js");
+const hooks_js_1 = require("../data/hooks.js");
+const components_js_1 = require("../data/components.js");
+describe('MCP integration (extra)', () => {
+    async function withClient(fn) {
+        const [clientTransport, serverTransport] = inMemory_js_1.InMemoryTransport.createLinkedPair();
+        const server = (0, server_js_1.createServer)();
+        const client = new index_js_1.Client({ name: 'integration-test', version: '1.0.0' });
+        await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
+        try {
+            return await fn(client);
+        }
+        finally {
+            await client.close();
+            await server.close();
+        }
+    }
+    test('get_server_capabilities: число tools соответствует фактическому', async () => {
+        await withClient(async (client) => {
+            const listed = await client.listTools();
+            const caps = await client.callTool({ name: 'get_server_capabilities', arguments: {} });
+            const data = caps.structuredContent;
+            // Подтверждаем, что tools_count в capabilities соответствует длине каталога.
+            expect(data.tools_count).toBe(listed.tools.length);
+            // И в частности — это все реально зарегистрированные tools.
+            expect(data.tools_count).toBe(100);
+        });
+    });
+    test('find_tool: известный запрос → matches не пустой', async () => {
+        await withClient(async (client) => {
+            const r = await client.callTool({
+                name: 'find_tool',
+                arguments: { query: 'создай дополнение' },
+            });
+            const data = r.structuredContent;
+            expect(Array.isArray(data.matches)).toBe(true);
+            expect(data.matches.length).toBeGreaterThan(0);
+        });
+    });
+    test('find_tool: ranked содержит информацию о релевантности', async () => {
+        await withClient(async (client) => {
+            const r = await client.callTool({
+                name: 'find_tool',
+                arguments: { query: 'audit project upgrade' },
+            });
+            const data = r.structuredContent;
+            expect(Array.isArray(data.ranked)).toBe(true);
+        });
+    });
+    test('get_workflow: каждый известный workflow отдаёт последовательность', async () => {
+        await withClient(async (client) => {
+            const workflows = ['addon', 'widget', 'template', 'audit', 'repair', 'upgrade'];
+            for (const name of workflows) {
+                const r = await client.callTool({ name: 'get_workflow', arguments: { workflow: name } });
+                const data = r.structuredContent;
+                expect(data.workflow).toBe(name);
+                expect(Array.isArray(data.tools)).toBe(true);
+                expect(data.tools.length).toBeGreaterThan(0);
+            }
+        });
+    });
+    test('explain_validation_error: известный код → success, неизвестный → error', async () => {
+        await withClient(async (client) => {
+            const ok = await client.callTool({
+                name: 'explain_validation_error',
+                arguments: { code: 'MISSING_REQUIRED_FILE' },
+            });
+            expect(ok.isError).toBeFalsy();
+            const bad = await client.callTool({
+                name: 'explain_validation_error',
+                arguments: { code: 'UNDEFINED_CODE_XYZ' },
+            });
+            expect(bad.isError).toBe(true);
+        });
+    });
+    test('compare_instantcms_versions: known и unknown', async () => {
+        await withClient(async (client) => {
+            const r = await client.callTool({
+                name: 'compare_instantcms_versions',
+                arguments: { from: '2.17', to: '2.18.2' },
+            });
+            expect(r.isError).toBeFalsy();
+            const r2 = await client.callTool({
+                name: 'compare_instantcms_versions',
+                arguments: { from: '99.99.99', to: '2.18.2' },
+            });
+            // Не isError — просто возвращает warnings.
+            expect(r2.isError).toBeFalsy();
+        });
+    });
+    test('get_project_health: возвращает status=ready', async () => {
+        await withClient(async (client) => {
+            const r = await client.callTool({ name: 'get_project_health', arguments: {} });
+            const data = r.structuredContent;
+            expect(data.status).toBe('ready');
+        });
+    });
+    test('validate_generated_artifacts: валидный набор → is_valid=true', async () => {
+        await withClient(async (client) => {
+            const r = await client.callTool({
+                name: 'validate_generated_artifacts',
+                arguments: {
+                    files: {
+                        'manifest.xml': '<?xml version="1.0"?><root/>',
+                        'layout.yaml': 'layout:\n  rows: []',
+                    },
+                },
+            });
+            const data = r.structuredContent;
+            expect(data.is_valid).toBe(true);
+        });
+    });
+    test('invalid input на list_hooks → isError', async () => {
+        await withClient(async (client) => {
+            const r = await client.callTool({
+                name: 'list_hooks',
+                arguments: { limit: -1 },
+            });
+            // Schema отвергает <0 и >200; Zod или no-throw поведение зависит от реализации.
+            // Минимум — не должно throw.
+            expect(r).toBeDefined();
+        });
+    });
+    test('tools/list contains весь critical tool set', async () => {
+        await withClient(async (client) => {
+            const listed = await client.listTools();
+            const names = new Set(listed.tools.map(t => t.name));
+            // Подмножество, которое ОБЯЗАНО быть для всех наших workflows.
+            const critical = [
+                'get_server_capabilities',
+                'find_tool',
+                'get_workflow',
+                'diagnose_request',
+                'list_hooks',
+                'get_hook_details',
+                'search_hooks',
+                'list_components',
+                'get_component_api',
+                'scaffold_addon',
+                'get_addon_structure',
+                'validate_addon',
+                'validate_generated_artifacts',
+                'build_addon_archive',
+                'inspect_addon_archive',
+                'get_field_types',
+            ];
+            for (const name of critical) {
+                expect(names.has(name)).toBe(true);
+            }
+        });
+    });
+    test('knowledge volume count matches встроенным справочникам', async () => {
+        await withClient(async (client) => {
+            const r = await client.callTool({ name: 'get_server_capabilities', arguments: {} });
+            const data = r.structuredContent;
+            expect(data.knowledge.hooks).toBe(hooks_js_1.hooks.length);
+            expect(data.knowledge.components).toBe(components_js_1.components.length);
+            expect(data.knowledge.addon_types.length).toBe(Object.keys(schemas_js_1.addonStructures).length);
+        });
+    });
+});

package/dist/__tests__/mcp-integration.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const inMemory_js_1 = require("@modelcontextprotocol/sdk/inMemory.js");
+const server_js_1 = require("../server.js");
+describe('MCP integration', () => {
+    test('lists tools and returns structured capabilities', async () => {
+        const [clientTransport, serverTransport] = inMemory_js_1.InMemoryTransport.createLinkedPair();
+        const server = (0, server_js_1.createServer)();
+        const client = new index_js_1.Client({ name: 'integration-test', version: '1.0.0' });
+        await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
+        try {
+            const listed = await client.listTools();
+            expect(listed.tools.some(tool => tool.name === 'get_server_capabilities')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'validate_generated_artifacts')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'audit_instantcms_project')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'plan_instantcms_upgrade')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'load_instantcms_project')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'create_project_patch')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'scaffold_complete_template')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'analyze_instantcms_template')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'check_template_override_compatibility')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'merge_template_overrides')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'audit_template_frontend')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'scaffold_template_e2e_environment')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'index_upstream_template_sources')).toBe(true);
+            expect(listed.tools.some(tool => tool.name === 'scaffold_template_php_quality')).toBe(true);
+            expect(listed.tools).toHaveLength(100);
+            const result = await client.callTool({ name: 'get_server_capabilities', arguments: {} });
+            expect(result.structuredContent).toMatchObject({ server_version: '1.2.3' });
+        }
+        finally {
+            await client.close();
+            await server.close();
+        }
+    });
+    test('supports pagination and rejects invalid input at protocol boundary', async () => {
+        const [clientTransport, serverTransport] = inMemory_js_1.InMemoryTransport.createLinkedPair();
+        const server = (0, server_js_1.createServer)();
+        const client = new index_js_1.Client({ name: 'integration-test', version: '1.0.0' });
+        await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
+        try {
+            const page = await client.callTool({ name: 'list_hooks', arguments: { limit: 2 } });
+            expect(page.structuredContent.page.returned).toBe(2);
+            const invalid = await client.callTool({ name: 'list_hooks', arguments: { limit: 5000 } });
+            expect(invalid.isError).toBe(true);
+        }
+        finally {
+            await client.close();
+            await server.close();
+        }
+    });
+});

package/dist/__tests__/pagination.test.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fc = __importStar(require("fast-check"));
+const pagination_js_1 = require("../utils/pagination.js");
+describe('pagination property-based', () => {
+    test('возвращённых элементов никогда не больше limit', () => {
+        fc.assert(fc.property(fc.array(fc.string(), { maxLength: 500 }), fc.integer({ min: -10, max: 300 }), (items, rawLimit) => {
+            const limit = rawLimit; // функция сама зажимает.
+            const page = (0, pagination_js_1.paginate)(items, { limit });
+            return page.items.length <= Math.max(1, Math.min(limit === 0 ? 50 : limit, 200));
+        }), { numRuns: 100 });
+    });
+    test('limit автоматически clamp в диапазон [1, 200]', () => {
+        fc.assert(fc.property(fc.array(fc.string(), { maxLength: 50 }), fc.integer({ min: -50, max: 1000 }), (items, limit) => {
+            const page = (0, pagination_js_1.paginate)(items, { limit });
+            return page.page.limit >= 1 && page.page.limit <= 200;
+        }), { numRuns: 100 });
+    });
+    test('limit по умолчанию равен 50', () => {
+        fc.assert(fc.property(fc.array(fc.string(), { maxLength: 100 }), items => {
+            const page = (0, pagination_js_1.paginate)(items);
+            return page.page.limit === 50;
+        }), { numRuns: 20 });
+    });
+    test('total отражает размер исходного массива', () => {
+        fc.assert(fc.property(fc.array(fc.string(), { maxLength: 200 }), fc.integer({ min: 1, max: 50 }), (items, limit) => {
+            const page = (0, pagination_js_1.paginate)(items, { limit });
+            return page.page.total === items.length;
+        }), { numRuns: 100 });
+    });
+    test('returned элементов равно длине страницы', () => {
+        fc.assert(fc.property(fc.array(fc.string(), { maxLength: 200 }), fc.integer({ min: 1, max: 100 }), (items, limit) => {
+            const page = (0, pagination_js_1.paginate)(items, { limit });
+            return page.page.returned === page.items.length;
+        }), { numRuns: 100 });
+    });
+    test('невалидный/повреждённый cursor безопасно стартует с 0', () => {
+        const cursors = ['', '!!not-base64!!', 'AAAA', '!!!!', '__$$', '\u0000\u0000', ' '];
+        for (const c of cursors) {
+            const result = (0, pagination_js_1.paginate)(['a', 'b', 'c'], { cursor: c, limit: 10 });
+            expect(result.items.length).toBeGreaterThanOrEqual(0);
+            expect(Array.isArray(result.items)).toBe(true);
+        }
+    });
+    test('cursor за пределами массива возвращает пустой список и next_cursor=null', () => {
+        const huge = (0, pagination_js_1.paginate)([1, 2, 3], { limit: 5, cursor: 'Zm9vYmFy' /* arbitrary */ });
+        // arbitrary base64 может распарситься в мусор; cursor никогда не должен сломать результат
+        expect(Array.isArray(huge.items)).toBe(true);
+    });
+    test('объединение всех страниц с корректными курсорами даёт исходный массив', () => {
+        fc.assert(fc.property(fc.array(fc.string({ maxLength: 50 }), { maxLength: 30 }), fc.integer({ min: 1, max: 7 }), (items, limit) => {
+            const result = [];
+            let cursor;
+            let safety = 100; // защита от бесконечного цикла
+            while (safety-- > 0) {
+                const page = (0, pagination_js_1.paginate)(items, { cursor, limit });
+                result.push(...page.items);
+                if (!page.page.next_cursor)
+                    break;
+                cursor = page.page.next_cursor;
+            }
+            return JSON.stringify(result) === JSON.stringify(items);
+        }), { numRuns: 50 });
+    });
+    test('пустой массив → пустой page с next_cursor=null', () => {
+        const page = (0, pagination_js_1.paginate)([]);
+        expect(page.items).toEqual([]);
+        expect(page.page.returned).toBe(0);
+        expect(page.page.total).toBe(0);
+        expect(page.page.next_cursor).toBeNull();
+        expect(page.page.limit).toBe(50);
+    });
+    test('массив короче limit → одна страница, next_cursor=null', () => {
+        fc.assert(fc.property(fc.array(fc.string(), { maxLength: 10 }), fc.integer({ min: 20, max: 200 }), (items, limit) => {
+            const page = (0, pagination_js_1.paginate)(items, { limit });
+            expect(page.items.length).toBe(items.length);
+            expect(page.page.next_cursor).toBeNull();
+            return true;
+        }), { numRuns: 30 });
+    });
+});

package/dist/__tests__/performance-baseline.test.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hooks_tool_js_1 = require("../tools/hooks-tool.js");
+const addon_tool_js_1 = require("../tools/addon-tool.js");
+const pagination_js_1 = require("../utils/pagination.js");
+const find_tool_js_1 = require("../utils/find-tool.js");
+describe('performance baseline', () => {
+    test('listHooks: < 50ms для одного вызова без пагинации', () => {
+        const start = Date.now();
+        (0, hooks_tool_js_1.listHooks)();
+        const elapsed = Date.now() - start;
+        expect(elapsed).toBeLessThan(50);
+    });
+    test('listHooks с пагинацией: < 50ms', () => {
+        const start = Date.now();
+        (0, hooks_tool_js_1.listHooks)(undefined, undefined, { limit: 100 });
+        const elapsed = Date.now() - start;
+        expect(elapsed).toBeLessThan(50);
+    });
+    test('listComponents: < 100ms', () => {
+        const start = Date.now();
+        (0, addon_tool_js_1.listComponents)();
+        const elapsed = Date.now() - start;
+        expect(elapsed).toBeLessThan(100);
+    });
+    test('paginate вызов: < 5ms', () => {
+        const arr = Array.from({ length: 1000 }, (_, i) => `item-${i}`);
+        const start = Date.now();
+        (0, pagination_js_1.paginate)(arr, { limit: 100 });
+        const elapsed = Date.now() - start;
+        expect(elapsed).toBeLessThan(5);
+    });
+    test('rankToolCategories: < 20ms на 10 категориях', () => {
+        const cats = Array.from({ length: 10 }, (_, i) => ({
+            category: `cat${i}`,
+            keywords: [`kw_${i}`, `kw_shared`],
+            tools: ['t1'],
+        }));
+        const start = Date.now();
+        (0, find_tool_js_1.rankToolCategories)('test query with multiple tokens', cats);
+        const elapsed = Date.now() - start;
+        expect(elapsed).toBeLessThan(20);
+    });
+    test('100 последовательных listHooks — без утечек', () => {
+        const startMem = process.memoryUsage().heapUsed;
+        for (let i = 0; i < 100; i += 1) {
+            (0, hooks_tool_js_1.listHooks)(undefined, undefined, { limit: 10 });
+        }
+        if (global.gc)
+            global.gc();
+        const endMem = process.memoryUsage().heapUsed;
+        const diffMb = (endMem - startMem) / 1024 / 1024;
+        // Достаточно грубая проверка — не растёт бесконтрольно.
+        expect(diffMb).toBeLessThan(5);
+    });
+});