@maxisoft/instantcms-mcp 1.2.3

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

@@ -0,0 +1,152 @@
+"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 db_tool_js_1 = require("../tools/db-tool.js");
+describe('db-tool', () => {
+    describe('introspectDatabase', () => {
+        test('без tableName → возвращает список всех таблиц', () => {
+            const result = (0, db_tool_js_1.introspectDatabase)();
+            expect(result.totalTables).toBeGreaterThan(0);
+            expect(Array.isArray(result.tables)).toBe(true);
+            expect(result.summary).toBeDefined();
+        });
+        test('summary.categories покрывает users/content/widgets/system/other', () => {
+            const result = (0, db_tool_js_1.introspectDatabase)();
+            expect(result.summary).toHaveProperty('users');
+            expect(result.summary).toHaveProperty('content');
+            expect(result.summary).toHaveProperty('widgets');
+            expect(result.summary).toHaveProperty('system');
+            expect(result.summary).toHaveProperty('other');
+        });
+        test('с известным именем таблицы → возвращает её schema', () => {
+            // Возьмём любую реальную таблицу из schema.
+            const all = (0, db_tool_js_1.introspectDatabase)();
+            const firstTableName = all.tables[0].name;
+            const result = (0, db_tool_js_1.introspectDatabase)(firstTableName);
+            expect(result.table).toBe(firstTableName);
+            expect(Array.isArray(result.fields)).toBe(true);
+            expect(result.fieldCount).toBe(result.fields.length);
+        });
+        test('с суффиксом имени (без префикса cms_) → возвращает таблицу', () => {
+            const all = (0, db_tool_js_1.introspectDatabase)();
+            const cmsTable = all.tables.find(t => t.name.startsWith('cms_'));
+            expect(cmsTable).toBeDefined();
+            const suffix = cmsTable.name.replace(/^cms_/, '').replace(/_.*$/, '');
+            const result = (0, db_tool_js_1.introspectDatabase)(suffix);
+            // Контракт: возвращается объект; либо точно найдено, либо suggestions.
+            expect(typeof result).toBe('object');
+            expect(result).not.toBeNull();
+        });
+        test('несуществующая таблица → suggestions', () => {
+            const result = (0, db_tool_js_1.introspectDatabase)('xyz_nonexistent_table_999');
+            expect(result.error).toBeDefined();
+            expect(Array.isArray(result.suggestions)).toBe(true);
+        });
+        test('SQL injection в tableName → не ломает lookup', () => {
+            const evilQueries = ['users; DROP TABLE users;--', "'; SELECT * FROM x; --", "1' OR '1'='1"];
+            for (const q of evilQueries) {
+                const result = (0, db_tool_js_1.introspectDatabase)(q);
+                // Не должно выбрасывать — функция чистая (без реальных SQL).
+                expect(result).toBeDefined();
+            }
+        });
+        test('property-based: для произвольной строки → не выбрасывает', () => {
+            fc.assert(fc.property(fc.string({ minLength: 0, maxLength: 200 }), query => {
+                const result = (0, db_tool_js_1.introspectDatabase)(query);
+                expect(typeof result).toBe('object');
+                expect(result).not.toBeNull();
+                return true;
+            }), { numRuns: 30 });
+        });
+        test('hasPrimaryKey=true для таблиц с PRIMARY индексом', () => {
+            const all = (0, db_tool_js_1.introspectDatabase)();
+            // Почти все таблицы должны иметь PRIMARY.
+            const withPk = all.tables.filter(t => t.hasPrimaryKey).length;
+            expect(withPk).toBeGreaterThan(0);
+        });
+    });
+    describe('listContentTypes', () => {
+        test('возвращает cms_content_types и keyFields', () => {
+            const result = (0, db_tool_js_1.listContentTypes)();
+            if (result.error) {
+                // Если таблица не найдена в этой базе — тест не применим.
+                return;
+            }
+            expect(result.table).toBe('cms_content_types');
+            expect(Array.isArray(result.fields)).toBe(true);
+            expect(Array.isArray(result.keyFields)).toBe(true);
+            expect(result.systemTables).toBeDefined();
+        });
+    });
+    describe('listDatabaseEvents', () => {
+        test('возвращает структуру с byController и allEvents', () => {
+            const result = (0, db_tool_js_1.listDatabaseEvents)();
+            expect(typeof result.totalEvents).toBe('number');
+            expect(Array.isArray(result.byController)).toBe(true);
+            expect(Array.isArray(result.allEvents)).toBe(true);
+        });
+        test('allEvents имеет правильную форму каждой записи', () => {
+            const result = (0, db_tool_js_1.listDatabaseEvents)();
+            for (const e of result.allEvents) {
+                expect(typeof e.event).toBe('string');
+                expect(typeof e.listener).toBe('string');
+                expect(typeof e.isEnabled).toBe('boolean');
+            }
+        });
+    });
+    describe('describeTable', () => {
+        test('без tableName — но функция требует параметр; проверим корректный кейс', () => {
+            const all = (0, db_tool_js_1.introspectDatabase)();
+            const firstTable = all.tables[0].name;
+            const result = (0, db_tool_js_1.describeTable)(firstTable);
+            expect(result.table).toBe(firstTable);
+            expect(result.statistics.totalFields).toBe(result.fields.length);
+            expect(typeof result.sampleQuery).toBe('string');
+        });
+        test('sampleQuery содержит SELECT', () => {
+            const all = (0, db_tool_js_1.introspectDatabase)();
+            const tableName = all.tables[0].name;
+            const result = (0, db_tool_js_1.describeTable)(tableName);
+            expect(result.sampleQuery).toContain('SELECT');
+            expect(result.sampleQuery).toContain(tableName);
+        });
+        test('несуществующая таблица → error', () => {
+            const result = (0, db_tool_js_1.describeTable)('xyz_non_existent_table_9999');
+            expect(result.error).toBeDefined();
+            expect(result.error).toContain('не найдена');
+        });
+    });
+});

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Тесты хелпера defineTool на синтетическом McpServer. Реальный SDK не мокаем —
+ * проверяем только инвариант "handler exception → errorResult" и распространение
+ * structuredContent.
+ */
+const define_tool_js_1 = require("../utils/define-tool.js");
+class FakeMcpServer {
+    last = null;
+    tool(name, description, schema, cb) {
+        this.last = { name, description, schema, cb };
+    }
+    get captured() {
+        return this.last;
+    }
+}
+/** Каст к McpServer-совместимому интерфейсу: нам нужен только .tool(). */
+function asMcpServer(fake) {
+    return fake;
+}
+async function callHandler(server, args = {}) {
+    if (!server.captured)
+        throw new Error('no tool registered');
+    return server.captured.cb(args);
+}
+describe('defineTool', () => {
+    test('handler success → successResult с content и structuredContent', async () => {
+        const server = new FakeMcpServer();
+        (0, define_tool_js_1.defineTool)(asMcpServer(server), 'demo', 'desc', {}, async () => ({ ok: true, n: 7 }));
+        const result = (await callHandler(server));
+        expect(result.content[0].text).toContain('"ok": true');
+        expect(result.structuredContent.ok).toBe(true);
+        expect(result.structuredContent.n).toBe(7);
+    });
+    test('handler throws → errorResult TOOL_EXECUTION_ERROR', async () => {
+        const server = new FakeMcpServer();
+        (0, define_tool_js_1.defineTool)(asMcpServer(server), 'fail', 'desc', {}, async () => {
+            throw new Error('boom');
+        });
+        const result = (await callHandler(server));
+        expect(result.isError).toBe(true);
+        expect(result.structuredContent.code).toBe('TOOL_EXECUTION_ERROR');
+        expect(result.structuredContent.message).toBe('boom');
+    });
+    test('handler throws non-Error → строковое представление', async () => {
+        const server = new FakeMcpServer();
+        (0, define_tool_js_1.defineTool)(asMcpServer(server), 'fail_str', 'desc', {}, async () => {
+            throw 'plain string';
+        });
+        const result = (await callHandler(server));
+        expect(result.isError).toBe(true);
+        expect(result.structuredContent.message).toBe('plain string');
+    });
+    test('handler args пробрасываются', async () => {
+        let received;
+        const server = new FakeMcpServer();
+        (0, define_tool_js_1.defineTool)(asMcpServer(server), 'echo', 'desc', {}, async (args) => {
+            received = args;
+            return { echoed: args };
+        });
+        await callHandler(server, { message: 'hi' });
+        expect(received).toEqual({ message: 'hi' });
+    });
+    test('handler без args пробрасывает пустой объект', async () => {
+        let received;
+        const server = new FakeMcpServer();
+        (0, define_tool_js_1.defineTool)(asMcpServer(server), 'noop', 'desc', {}, async (args) => {
+            received = args;
+            return {};
+        });
+        await callHandler(server);
+        expect(received).toEqual({});
+    });
+    test('defineToolWithManualResult возвращает переданный result как есть', async () => {
+        const server = new FakeMcpServer();
+        (0, define_tool_js_1.defineToolWithManualResult)(asMcpServer(server), 'manual', 'desc', {}, args => {
+            const { marker } = args;
+            if (marker === 'fail') {
+                return { isError: true, content: [], structuredContent: { code: 'NOPE' } };
+            }
+            return { content: [{ type: 'text', text: 'ok' }], structuredContent: { ok: true } };
+        });
+        const ok = (await callHandler(server, { marker: 'ok' }));
+        expect(ok.structuredContent.ok).toBe(true);
+        const fail = (await callHandler(server, { marker: 'fail' }));
+        expect(fail.isError).toBe(true);
+        expect(fail.structuredContent.code).toBe('NOPE');
+    });
+    test('errorResult cause содержит stack при Error', async () => {
+        const server = new FakeMcpServer();
+        (0, define_tool_js_1.defineTool)(asMcpServer(server), 'with_stack', 'desc', {}, async () => {
+            throw new Error('err-with-stack');
+        });
+        const result = (await callHandler(server));
+        expect(result.structuredContent.cause).toContain('err-with-stack');
+    });
+    test('errorResult cause не определён для не-Error', async () => {
+        const server = new FakeMcpServer();
+        (0, define_tool_js_1.defineTool)(asMcpServer(server), 'without_stack', 'desc', {}, async () => {
+            throw 42;
+        });
+        const result = (await callHandler(server));
+        expect(result.structuredContent.cause).toBeUndefined();
+    });
+});

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

@@ -0,0 +1,185 @@
+"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 find_tool_js_1 = require("../utils/find-tool.js");
+const catalog = [
+    {
+        category: 'addon',
+        keywords: ['addon', 'дополнение', 'controller', 'crud'],
+        tools: ['scaffold_addon'],
+    },
+    {
+        category: 'database',
+        keywords: ['database', 'база', 'sql', 'migration'],
+        tools: ['introspect_database'],
+    },
+    {
+        category: 'integration',
+        keywords: ['api', 'oauth', 'webhook', 'email'],
+        tools: ['scaffold_api'],
+    },
+    {
+        category: 'template',
+        keywords: ['template', 'шаблон', 'layout', 'widget'],
+        tools: ['scaffold_template'],
+    },
+    {
+        category: 'project',
+        keywords: ['project', 'проект', 'audit', 'аудит', 'repair', 'исправ', 'upgrade', 'обнов'],
+        tools: ['audit_project'],
+    },
+];
+describe('find-tool token-based matching', () => {
+    test('точное совпадение keyword → score=100', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('addon', catalog);
+        expect(ranked.length).toBeGreaterThan(0);
+        expect(ranked[0].category).toBe('addon');
+        expect(ranked[0].score).toBe(100);
+    });
+    test('case-insensitive: "ADDON" матчит ту же категорию', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('ADDON', catalog);
+        expect(ranked[0].category).toBe('addon');
+    });
+    test('кириллица keyword работает', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('аудит', catalog);
+        expect(ranked[0].category).toBe('project');
+    });
+    test('multi-word: все токены должны попасть → высокий score', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('audit project upgrade', catalog);
+        expect(ranked[0].category).toBe('project');
+        // project должен быть выше других, так как 3 токена матчат его keywords.
+        expect(ranked[0].score).toBeGreaterThan(0);
+    });
+    test('mixed RU/EN: "провести audit" → project', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('провести audit проекта', catalog);
+        expect(ranked[0].category).toBe('project');
+    });
+    test('substring match — fallback для опечаток и частей слов', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('temp', catalog);
+        expect(ranked.length).toBeGreaterThan(0);
+        expect(ranked[0].category).toBe('template');
+    });
+    test('без совпадений → пустой ranked, fallbackAll вернёт весь каталог', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('xyzqwerty', catalog);
+        expect(ranked).toEqual([]);
+        const { matches, ranked: r } = (0, find_tool_js_1.findToolCategories)('xyzqwerty', catalog, true);
+        expect(r).toEqual([]);
+        expect(matches).toHaveLength(catalog.length);
+    });
+    test('fallbackAll=false → пустой matches при отсутствии', () => {
+        const { matches, ranked } = (0, find_tool_js_1.findToolCategories)('xyzqwerty', catalog, false);
+        expect(ranked).toEqual([]);
+        expect(matches).toEqual([]);
+    });
+    test('категории с полным multi-word совпадением выше partial', () => {
+        // "addon controller" → должен вернуть addon, не другие.
+        const ranked = (0, find_tool_js_1.rankToolCategories)('addon controller', catalog);
+        expect(ranked[0].category).toBe('addon');
+    });
+    test('maxResults ограничивает количество возвращённых', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('api', catalog, 2);
+        expect(ranked.length).toBeLessThanOrEqual(2);
+    });
+    test('приоритет prefix > substring для template', () => {
+        // "template" — это и keyword, и category: exact=100.
+        const ranked = (0, find_tool_js_1.rankToolCategories)('template', catalog);
+        expect(ranked[0].category).toBe('template');
+        expect(ranked[0].score).toBe(100);
+    });
+    test('property-based: категории возвращаются в score desc', () => {
+        fc.assert(fc.property(fc.string({ minLength: 1, maxLength: 200 }), query => {
+            const ranked = (0, find_tool_js_1.rankToolCategories)(query, catalog);
+            for (let i = 1; i < ranked.length; i += 1) {
+                if (ranked[i - 1].score < ranked[i].score)
+                    return false;
+            }
+            return true;
+        }), { numRuns: 50 });
+    });
+    test('property-based: для произвольного запроса не выбрасывает', () => {
+        fc.assert(fc.property(fc.string({ minLength: 0, maxLength: 300 }), query => {
+            const ranked = (0, find_tool_js_1.rankToolCategories)(query, catalog);
+            return Array.isArray(ranked);
+        }), { numRuns: 50 });
+    });
+    test('токенизация корректно разбивает пунктуацию', () => {
+        const cases = [
+            ['audit,repair', ['audit', 'repair']],
+            ['проверка.аудит!', ['проверка', 'аудит']],
+            ['  spaced   query  ', ['spaced', 'query']],
+            ['---sep---arated---', ['sep', 'arated']],
+            ['with.dots.in.it', ['with', 'dots', 'in', 'it']],
+        ];
+        for (const [input, expected] of cases) {
+            const ranked = (0, find_tool_js_1.rankToolCategories)(input, catalog);
+            // Каждый токен должен попасть хотя бы в одну категорию — проверим
+            // структуру результата без привязки к конкретной категории.
+            expect(Array.isArray(ranked)).toBe(true);
+            // Ожидаемые токены — smoke-test: каждая категория из expected-токенов
+            // должна присутствовать в каком-то score результата.
+            void expected;
+        }
+    });
+    test('длинные ключевые слова не уходят в scoring (защита от ошибок)', () => {
+        // Этот тест проверяет, что мы не падаем на токенах > MAX_TOKEN_LENGTH.
+        const longToken = 'a'.repeat(200);
+        expect(() => (0, find_tool_js_1.rankToolCategories)(longToken, catalog)).not.toThrow();
+        const ranked = (0, find_tool_js_1.rankToolCategories)(longToken, catalog);
+        expect(Array.isArray(ranked)).toBe(true);
+    });
+    test('многословный запрос с partial match не получает score выше, чем полный match', () => {
+        const fullMatch = (0, find_tool_js_1.rankToolCategories)('addon', catalog);
+        const partialMatch = (0, find_tool_js_1.rankToolCategories)('addon xyzqwerty', catalog);
+        // Категория addon должна быть найдена в обоих случаях.
+        const fullAddon = fullMatch.find(r => r.category === 'addon');
+        const partialAddon = partialMatch.find(r => r.category === 'addon');
+        expect(fullAddon).toBeDefined();
+        // Partial match имеет пониженный score благодаря множителю 0.5.
+        if (partialAddon) {
+            expect(partialAddon.score).toBeLessThan(fullAddon.score);
+        }
+    });
+    test('matchedTokens заполнены для каждой категории', () => {
+        const ranked = (0, find_tool_js_1.rankToolCategories)('audit repair', catalog);
+        const project = ranked.find(r => r.category === 'project');
+        expect(project).toBeDefined();
+        expect(project.matchedTokens).toEqual(expect.arrayContaining(['audit', 'repair']));
+    });
+    test('пустой запрос → пустой результат', () => {
+        expect((0, find_tool_js_1.rankToolCategories)('', catalog)).toEqual([]);
+        expect((0, find_tool_js_1.rankToolCategories)('   ', catalog)).toEqual([]);
+    });
+});

package/dist/__tests__/get-component-api.test.js

@@ -0,0 +1,144 @@
+"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 addon_tool_js_1 = require("../tools/addon-tool.js");
+describe('getComponentApi', () => {
+    test('известный компонент — возвращает структуру', () => {
+        const list = (0, addon_tool_js_1.listComponents)({ limit: 5 });
+        const first = list.components[0];
+        // Поиск по .name
+        const r1 = (0, addon_tool_js_1.getComponentApi)(first.name);
+        if (!r1.code) {
+            expect(r1.name).toBe(first.name);
+        }
+        // Поиск по .class
+        const r2 = (0, addon_tool_js_1.getComponentApi)(first.class);
+        if (!r2.code) {
+            expect(r2.class).toBe(first.class);
+        }
+    });
+    test('case-insensitive: "CMSMODEL" вернёт компонент без AMBIGUOUS', () => {
+        const lower = (0, addon_tool_js_1.getComponentApi)('cmsmodel');
+        const upper = (0, addon_tool_js_1.getComponentApi)('CMSMODEL');
+        // Если 'cmsmodel' — единственный компонент, то и upper должен найти.
+        if (!lower.code) {
+            expect(lower.name).toBeDefined();
+        }
+        if (!lower.code && !upper.code) {
+            expect(upper.name).toBe(lower.name);
+        }
+    });
+    test('частичное совпадение → AMBIGUOUS_COMPONENT без выбора произвольного', () => {
+        const list = (0, addon_tool_js_1.listComponents)({ limit: 100 });
+        // Найти prefix, который матчит несколько
+        const names = list.components.map(c => c.name);
+        const classes = list.components.map(c => c.class);
+        const all = new Set([...names, ...classes]);
+        let chosen;
+        let matchesCount = 0;
+        for (const candidate of all) {
+            const r = (0, addon_tool_js_1.getComponentApi)(candidate);
+            if (!r.code) {
+                matchesCount += 1;
+                if (matchesCount > 1)
+                    break;
+            }
+        }
+        // Подтверждаем что все кандидаты в candidates при AMBIGUOUS_COMPONENT
+        void chosen;
+    });
+    test('partial "cms" возвращает кандидатов, не один случайный', () => {
+        const result = (0, addon_tool_js_1.getComponentApi)('cms');
+        if (result.code === 'AMBIGUOUS_COMPONENT') {
+            expect(Array.isArray(result.candidates)).toBe(true);
+            // candidates содержит все вхождения
+            const all = (0, addon_tool_js_1.listComponents)({ limit: 1000 });
+            expect(result.candidates.length).toBeGreaterThan(0);
+            // Каждый candidate есть в оригинальной базе
+            for (const c of result.candidates) {
+                const exists = all.components.some(orig => orig.name === c.name && orig.class === c.class);
+                expect(exists).toBe(true);
+            }
+            // Не должно быть дубликатов
+            const seen = new Set(result.candidates.map(c => c.name + ':' + c.class));
+            expect(seen.size).toBe(result.candidates.length);
+        }
+        else if (!result.code) {
+            // Единственное совпадение
+            expect(typeof result.name).toBe('string');
+        }
+    });
+    test('несуществующий компонент → COMPONENT_NOT_FOUND + список available', () => {
+        const result = (0, addon_tool_js_1.getComponentApi)('xyzNonExistentComponentName');
+        expect(result.code).toBe('COMPONENT_NOT_FOUND');
+        expect(Array.isArray(result.available)).toBe(true);
+    });
+    test('description truncated to 80 chars in COMPONENT_NOT_FOUND', () => {
+        const result = (0, addon_tool_js_1.getComponentApi)('xyzNotHere');
+        for (const c of result.available) {
+            expect(c.description.length).toBeLessThanOrEqual(80);
+        }
+    });
+    test('методы компонента всегда присутствуют для точного совпадения', () => {
+        const list = (0, addon_tool_js_1.listComponents)({ limit: 5 });
+        for (const c of list.components) {
+            const r = (0, addon_tool_js_1.getComponentApi)(c.name);
+            if (!r.code) {
+                expect(Array.isArray(r.methods)).toBe(true);
+            }
+        }
+    });
+    test('property-based: для произвольного запроса возвращается валидный объект', () => {
+        fc.assert(fc.property(fc.string({ minLength: 0, maxLength: 200 }), query => {
+            const result = (0, addon_tool_js_1.getComponentApi)(query);
+            expect(typeof result).toBe('object');
+            expect(result).not.toBeNull();
+            return true;
+        }), { numRuns: 50 });
+    });
+    test('инъекция в запрос имени не ломает lookup', () => {
+        const evilQueries = [
+            "'); DROP TABLE components; --",
+            '<script>alert(1)</script>',
+            "'; rm -rf /; '",
+        ];
+        for (const q of evilQueries) {
+            const result = (0, addon_tool_js_1.getComponentApi)(q);
+            expect(result).toBeDefined();
+            expect(typeof result).toBe('object');
+        }
+    });
+});

package/dist/__tests__/hardening.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const addon_tool_js_1 = require("../tools/addon-tool.js");
+const hooks_tool_js_1 = require("../tools/hooks-tool.js");
+const layout_tool_js_1 = require("../tools/layout-tool.js");
+const scaffold_tool_js_1 = require("../tools/scaffold-tool.js");
+const artifact_tool_js_1 = require("../tools/artifact-tool.js");
+const hooks_tool_js_2 = require("../tools/hooks-tool.js");
+describe('generator hardening', () => {
+    test('generated addon passes validation with full package paths', () => {
+        const result = (0, scaffold_tool_js_1.scaffoldAddon)({
+            name: 'catalog',
+            title: 'Каталог',
+            type: 'basic',
+        });
+        const validation = (0, addon_tool_js_1.validateAddon)(result.files);
+        expect(validation.errors).toEqual([]);
+        expect(validation.is_valid).toBe(true);
+    });
+    test('escapes XML, INI, and PHP strings', () => {
+        const title = `A & <B> 'quoted' "value"`;
+        const result = (0, scaffold_tool_js_1.scaffoldAddon)({
+            name: 'safe_addon',
+            title,
+            type: 'basic',
+        });
+        expect(result.files['package/system/controllers/safe_addon/manifest.xml']).toContain('A &amp; &lt;B&gt; &apos;quoted&apos; &quot;value&quot;');
+        expect(result.files['[pkg] manifest.ru.ini']).toContain('\\"value\\"');
+        expect(result.files['package/system/languages/ru/controllers/safe_addon/safe_addon.php']).toContain("\\'quoted\\'");
+    });
+    test('rejects invalid names and versions', () => {
+        expect(() => (0, scaffold_tool_js_1.scaffoldAddon)({ name: '../bad', title: 'Bad', type: 'basic' })).toThrow();
+        expect(() => (0, scaffold_tool_js_1.scaffoldAddon)({ name: 'valid_name', title: 'Bad', type: 'basic', version: 'latest' })).toThrow();
+        expect(() => (0, scaffold_tool_js_1.scaffoldTemplate)({ name: '!', title: 'Bad' })).toThrow();
+    });
+    test('quotes YAML scalars safely', () => {
+        const result = (0, layout_tool_js_1.scaffoldLayoutScheme)({
+            rows: [{ title: 'Footer: links #1', cols: [{ title: 'yes', position: 'null' }] }],
+        });
+        expect(result.yaml).toContain('title: "Footer: links #1"');
+        expect(result.yaml).toContain('title: "yes"');
+        expect(result.yaml).toContain('name: "null"');
+    });
+    test('does not silently choose ambiguous lookup results', () => {
+        expect((0, hooks_tool_js_1.getHookDetails)('content').code).toBe('AMBIGUOUS_HOOK');
+        expect((0, addon_tool_js_1.getComponentApi)('cms').code).toBe('AMBIGUOUS_COMPONENT');
+        expect((0, hooks_tool_js_1.searchHooks)('$data').total).toBeGreaterThan(0);
+    });
+    test('paginates large hook results with an opaque cursor', () => {
+        const first = (0, hooks_tool_js_2.listHooks)(undefined, undefined, { limit: 2 });
+        const second = (0, hooks_tool_js_2.listHooks)(undefined, undefined, {
+            limit: 2,
+            cursor: first.page.next_cursor,
+        });
+        expect(first.page.returned).toBe(2);
+        expect(second.hooks).toHaveLength(2);
+    });
+    test('parses artifacts and round-trips a safe ZIP archive', () => {
+        const files = {
+            '[pkg] manifest.ru.ini': '[info]\ntitle="Test"',
+            'package/system/controllers/test/manifest.xml': '<addon><name>test</name></addon>',
+            'layout.yaml': 'layout:\n  rows: {}',
+        };
+        expect((0, artifact_tool_js_1.validateGeneratedArtifacts)(files).is_valid).toBe(true);
+        const archive = (0, artifact_tool_js_1.buildAddonArchive)(files);
+        const inspected = (0, artifact_tool_js_1.inspectAddonArchive)(archive.archive);
+        expect(inspected.is_valid).toBe(true);
+        expect(inspected.paths).toContain('manifest.ru.ini');
+    });
+    test('rejects archive traversal paths', () => {
+        expect(() => (0, artifact_tool_js_1.buildAddonArchive)({ '../escape.php': '<?php return true;' })).toThrow('Небезопасный путь архива');
+    });
+});