iwgt 2.4.9 → 2.4.10

package/dist/data/insales-permanent-links.json

@@ -0,0 +1,68 @@
+{
+    "description": "Постоянные ссылки InSales для основных разделов сайта",
+    "links": {
+        "cart": {
+            "url": "{{ cart_url }}",
+            "description": "Ссылка на корзину покупок",
+            "usage": "Используется в виджетах для перехода в корзину",
+            "examples": [
+                "href=\"{{ cart_url }}\"",
+                "action=\"{{ cart_url }}\""
+            ]
+        },
+        "cart_items": {
+            "url": "/cart_items",
+            "description": "Ссылка на страницу корзины (для форм)",
+            "usage": "Используется в формах для обновления корзины",
+            "examples": [
+                "action=\"/cart_items\""
+            ]
+        },
+        "compare": {
+            "url": "/compares",
+            "description": "Ссылка на страницу сравнения товаров",
+            "usage": "Используется в шапке и других виджетах для перехода к сравнению",
+            "examples": [
+                "href=\"/compares\""
+            ]
+        },
+        "favorites": {
+            "url": "/favorites",
+            "description": "Ссылка на страницу избранных товаров",
+            "usage": "Используется в шапке и других виджетах для перехода к избранному",
+            "examples": [
+                "href=\"/favorites\""
+            ]
+        },
+        "personal_account": {
+            "url": "/client_account/orders",
+            "description": "Ссылка на личный кабинет (заказы)",
+            "usage": "Используется в шапке для перехода в личный кабинет",
+            "examples": [
+                "href=\"/client_account/orders\""
+            ]
+        },
+        "personal_feedback": {
+            "url": "/client_account/feedback",
+            "description": "Ссылка на форму обратной связи в личном кабинете",
+            "usage": "Используется в формах обратной связи",
+            "examples": [
+                "action=\"/client_account/feedback\""
+            ]
+        },
+        "search": {
+            "url": "/search",
+            "description": "Ссылка на страницу поиска",
+            "usage": "Используется в формах поиска",
+            "examples": [
+                "action=\"/search\""
+            ]
+        }
+    },
+    "notes": [
+        "Эти ссылки являются постоянными в системе InSales и не должны изменяться",
+        "cart_url - это переменная Liquid, которая автоматически генерирует правильную ссылку на корзину",
+        "Все остальные ссылки являются статическими путями",
+        "При создании виджетов используйте эти ссылки вместо выдуманных типа pages.favorite.url"
+    ]
+}

package/dist/data/references/commonjs-reference.json

@@ -1,6 +1,6 @@
 {
     "version": "2.0",
-    "generatedAt": "2025-10-08T21:45:54.929Z",
+    "generatedAt": "2025-10-08T23:00:14.856Z",
     "description": "Справочник по библиотеке common.v2.js для InSales - набор готовых скриптов для разработки шаблонов",
     "installation": {
         "method": "liquid_tag",

package/dist/data/references/icons-registry.json

@@ -289,6 +289,27 @@
                         "hide"
                     ]
                 },
+                {
+                    "name": "favorites",
+                    "file": "favorites.svg",
+                    "keywords": [
+                        "favorites"
+                    ]
+                },
+                {
+                    "name": "favorites-f",
+                    "file": "favorites-f.svg",
+                    "keywords": [
+                        "favorites-f"
+                    ]
+                },
+                {
+                    "name": "favorites-o",
+                    "file": "favorites-o.svg",
+                    "keywords": [
+                        "favorites-o"
+                    ]
+                },
                 {
                     "name": "file-code-o",
                     "file": "file-code-o.svg",
@@ -312,28 +333,10 @@
                     ]
                 },
                 {
-                    "name": "heart",
-                    "file": "heart.svg",
+                    "name": "home",
+                    "file": "home.svg",
                     "keywords": [
-                        "избранное",
-                        "лайк",
-                        "сердце",
-                        "favorite",
-                        "like",
-                        "heart"
-                    ]
-                },
-                {
-                    "name": "heart-o",
-                    "file": "heart-o.svg",
-                    "keywords": [
-                        "избранное",
-                        "лайк",
-                        "сердце",
-                        "favorite",
-                        "like",
-                        "heart",
-                        "empty"
+                        "home"
                     ]
                 },
                 {
@@ -431,6 +434,13 @@
                         "phone"
                     ]
                 },
+                {
+                    "name": "order",
+                    "file": "order.svg",
+                    "keywords": [
+                        "order"
+                    ]
+                },
                 {
                     "name": "paper-plane",
                     "file": "paper-plane.svg",
@@ -485,6 +495,13 @@
                         "plus-circle"
                     ]
                 },
+                {
+                    "name": "preorder",
+                    "file": "preorder.svg",
+                    "keywords": [
+                        "preorder"
+                    ]
+                },
                 {
                     "name": "question",
                     "file": "question.svg",
@@ -653,7 +670,7 @@
                     ]
                 }
             ],
-            "total": 76
+            "total": 80
         }
     },
     "categories": {
@@ -676,8 +693,6 @@
         "commerce": [
             "cart",
             "credit-card",
-            "heart",
-            "heart-o",
             "shopping-cart"
         ],
         "communication": [

package/dist/data/references/liquid-filters.json

@@ -4,7 +4,7 @@
         "description": "Liquid фильтры InSales",
         "totalCategories": 7,
         "totalFilters": 53,
-        "generatedAt": "2025-10-08T21:45:54.918Z"
+        "generatedAt": "2025-10-08T23:00:14.836Z"
     },
     "categories": [
         {

package/dist/data/references/liquid-variables.json

@@ -4,7 +4,7 @@
         "description": "Liquid переменные InSales",
         "totalCategories": 19,
         "totalVariables": 436,
-        "generatedAt": "2025-10-08T21:45:54.712Z"
+        "generatedAt": "2025-10-08T23:00:14.500Z"
     },
     "categories": [
         {

package/dist/generators/index.d.ts

@@ -84,4 +84,27 @@ export declare function generateCollectionsMenu(args: {
  * Генерирует все файлы виджета
  */
 export declare function generateWidgetFiles(config: WidgetConfig): Record<string, any>;
+/**
+ * Валидирует Liquid код на наличие несуществующих фильтров
+ */
+export declare function validateLiquidFilters(liquidCode: string): {
+    isValid: boolean;
+    errors: Array<{
+        filter: string;
+        line: number;
+        column: number;
+        suggestion: string;
+    }>;
+};
+/**
+ * Проверяет и исправляет несуществующие фильтры в Liquid коде
+ */
+export declare function fixInvalidFilters(liquidCode: string): {
+    fixedCode: string;
+    fixes: Array<{
+        filter: string;
+        line: number;
+        suggestion: string;
+    }>;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/generators/index.js

@@ -1038,7 +1038,30 @@ export function generateWidgetFiles(config) {
     files['settings_form.json'] = settingsForm.form;
     files['settings_form'] = { settingsCount: settingsForm.count }; // метаинформация
     // snippet.liquid
-    files['snippet.liquid'] = generateSnippetLiquid(config);
+    const liquidCode = generateSnippetLiquid(config);
+    // Валидируем Liquid код на несуществующие фильтры
+    const validation = validateLiquidFilters(liquidCode);
+    if (!validation.isValid) {
+        console.warn('⚠️ Обнаружены несуществующие фильтры в Liquid коде:');
+        validation.errors.forEach(error => {
+            console.warn(`  - Строка ${error.line}: фильтр '${error.filter}' - ${error.suggestion}`);
+        });
+        // Автоматически исправляем несуществующие фильтры
+        const fixed = fixInvalidFilters(liquidCode);
+        if (fixed.fixes.length > 0) {
+            console.log('✅ Автоматически исправлены несуществующие фильтры:');
+            fixed.fixes.forEach(fix => {
+                console.log(`  - Строка ${fix.line}: ${fix.suggestion}`);
+            });
+            files['snippet.liquid'] = fixed.fixedCode;
+        }
+        else {
+            files['snippet.liquid'] = liquidCode;
+        }
+    }
+    else {
+        files['snippet.liquid'] = liquidCode;
+    }
     // snippet.scss
     files['snippet.scss'] = generateSnippetScss(config);
     // snippet.js
@@ -1049,4 +1072,71 @@ export function generateWidgetFiles(config) {
     }
     return files;
 }
+/**
+ * Валидирует Liquid код на наличие несуществующих фильтров
+ */
+export function validateLiquidFilters(liquidCode) {
+    const invalidFiltersList = [
+        { name: 't', suggestion: 'Используйте messages или widget_messages для переводов' },
+        { name: 'translate', suggestion: 'Используйте messages для переводов' },
+        { name: 'i18n', suggestion: 'Используйте messages для переводов' },
+        { name: 'l', suggestion: 'Используйте messages для переводов' },
+        { name: 'localize', suggestion: 'Используйте messages для переводов' },
+        { name: 'tr', suggestion: 'Используйте messages для переводов' }
+    ];
+    const errors = [];
+    const lines = liquidCode.split('\n');
+    lines.forEach((line, lineIndex) => {
+        invalidFiltersList.forEach(invalidFilter => {
+            // Ищем паттерн | filter_name
+            const regex = new RegExp(`\\|\\s*${invalidFilter.name}\\b`, 'g');
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                errors.push({
+                    filter: invalidFilter.name,
+                    line: lineIndex + 1,
+                    column: match.index + 1,
+                    suggestion: invalidFilter.suggestion
+                });
+            }
+        });
+    });
+    return {
+        isValid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Проверяет и исправляет несуществующие фильтры в Liquid коде
+ */
+export function fixInvalidFilters(liquidCode) {
+    const fixes = [];
+    let fixedCode = liquidCode;
+    // Исправляем фильтр 't' на messages
+    const tRegex = /\|\s*t\b/g;
+    let match;
+    while ((match = tRegex.exec(fixedCode)) !== null) {
+        const beforeMatch = fixedCode.substring(0, match.index);
+        const afterMatch = fixedCode.substring(match.index + match[0].length);
+        // Определяем, что это за контекст
+        const contextBefore = beforeMatch.substring(Math.max(0, beforeMatch.length - 50));
+        if (contextBefore.includes('widget_messages')) {
+            // Если это в контексте widget_messages, оставляем как есть
+            continue;
+        }
+        else {
+            // Заменяем на messages
+            fixedCode = beforeMatch + '| messages' + afterMatch;
+            fixes.push({
+                filter: 't',
+                line: fixedCode.substring(0, match.index).split('\n').length,
+                suggestion: 'Заменен на messages'
+            });
+        }
+    }
+    return {
+        fixedCode,
+        fixes
+    };
+}
 //# sourceMappingURL=index.js.map

package/dist/server-http.js

@@ -57,7 +57,7 @@ const httpServer = createServer(async (req, res) => {
         res.end(JSON.stringify({
             status: 'ok',
             service: 'InSales Widgets MCP Server',
-            version: '2.4.7',
+            version: '2.4.10',
             transport: 'SSE',
             endpoints: {
                 sse: '/sse',

package/dist/server.js

@@ -26,7 +26,7 @@ export class WidgetServer {
     constructor() {
         this.server = new Server({
             name: 'insales-widgets',
-            version: '2.4.9',
+            version: '2.4.10',
         }, {
             capabilities: {
                 tools: {},
@@ -238,6 +238,19 @@ export class WidgetServer {
                         },
                     },
                 },
+                {
+                    name: 'get_insales_permanent_links',
+                    description: 'Получить постоянные ссылки InSales для основных разделов сайта (корзина, избранное, сравнение, личный кабинет). Используйте эти ссылки вместо выдуманных типа pages.favorite.url',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            search: {
+                                type: 'string',
+                                description: 'Поиск ссылок по названию или описанию',
+                            },
+                        },
+                    },
+                },
             ],
         }));
         // Список ресурсов
@@ -521,6 +534,15 @@ export class WidgetServer {
                                 },
                             ],
                         };
+                    case 'get_insales_permanent_links':
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(tools.getInsalesPermanentLinks(args || {}), null, 2),
+                                },
+                            ],
+                        };
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }

package/dist/tools/index.d.ts

@@ -14,22 +14,17 @@ export declare function getAvailableIcons(args?: any): any;
 /**
  * Получить информацию о категории виджетов
  */
-export declare function getCategoryInfo(args: any): any;
+export declare function getCategoryInfo(args?: any): any;
 /**
  * Получить информацию о библиотеках
  */
 export declare function getLibrariesInfo(args?: any): any;
-/**
- * Получить справочник Liquid переменных
- */
-export declare function getLiquidVariables(args?: any): any;
 /**
  * Получить справочник Liquid фильтров
  */
 export declare function getLiquidFilters(args?: any): any;
 /**
- * Получить справочник CommonJS API v2 для InSales
- * ОБНОВЛЕНО: использует commonjs-api-complete.json с акцентом на глобальные переменные
+ * Получить справочник CommonJS API
  */
 export declare function getCommonJSAPI(args?: any): any;
 /**
@@ -37,8 +32,15 @@ export declare function getCommonJSAPI(args?: any): any;
  */
 export declare function getCollectionsMenuPatterns(args?: any): any;
 /**
- * Получить справочник API библиотек
- * Объединяет информацию из libraries-registry и libraries-api-reference
+ * Получить API библиотек
  */
 export declare function getLibrariesAPI(args?: any): any;
+/**
+ * Получить справочник Liquid переменных
+ */
+export declare function getLiquidVariables(args?: any): any;
+/**
+ * Получить постоянные ссылки InSales
+ */
+export declare function getInsalesPermanentLinks(args?: any): any;
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -12,6 +12,7 @@ import liquidFilters from '../data/references/liquid-filters.json' with { type:
 import commonjsApiComplete from '../data/references/commonjs-api-complete.json' with { type: 'json' };
 import collectionsMenuPatterns from '../data/references/collections-menu-patterns.json' with { type: 'json' };
 import librariesApiReference from '../data/references/libraries-api-reference.json' with { type: 'json' };
+import insalesPermanentLinks from '../data/insales-permanent-links.json' with { type: 'json' };
 /**
  * Получить список блок-темплейтов с фильтрацией
  */
@@ -31,17 +32,15 @@ export function getBlockTemplates(args = {}) {
     }
     return {
         total: templates.length,
-        category: category || 'all',
         templates: templates.map((t) => ({
             handle: t.handle,
             name: t.name,
+            description: t.description,
             keywords: t.keywords,
-            fields: t.fields.map((f) => ({
-                name: f.name,
-                handle: f.handle,
-                kind: f.kind,
-            })),
-        })),
+            category: t.category,
+            type: t.type,
+            usage: t.usage
+        }))
     };
 }
 /**
@@ -50,12 +49,10 @@ export function getBlockTemplates(args = {}) {
  */
 export function getAvailableIcons(args = {}) {
     const { search, category } = args;
-    const iconsData = iconsRegistry;
-    const defaultIcons = iconsData.iconSets?.default?.icons || [];
-    let icons = defaultIcons;
+    const data = iconsRegistry;
+    let icons = data.icons || [];
     if (category) {
-        const categoryIcons = iconsData.categories?.[category] || [];
-        icons = icons.filter((icon) => categoryIcons.includes(icon.name));
+        icons = icons.filter((icon) => icon.category === category);
     }
     if (search) {
         const searchLower = search.toLowerCase();
@@ -64,46 +61,35 @@ export function getAvailableIcons(args = {}) {
     }
     return {
         total: icons.length,
-        description: 'Иконки используются через иконочный шрифт, который уже подключен в шаблоне',
-        usage: {
-            liquid: 'В Liquid шаблонах: <i class="icon icon-название"></i>',
-            html: 'В HTML/JS: <i class="icon icon-название"></i>',
-            example: '<i class="icon icon-cart"></i> <!-- выведет иконку корзины -->',
-            note: 'Фильтра | icon НЕ СУЩЕСТВУЕТ в InSales. Используйте только HTML классы.'
-        },
         icons: icons.map((icon) => ({
             name: icon.name,
+            class: `icon-${icon.name}`,
             keywords: icon.keywords,
-            htmlClass: `<i class="icon icon-${icon.name}"></i>`,
-            className: `icon icon-${icon.name}`,
-        })),
+            category: icon.category,
+            usage: `<i class="icon icon-${icon.name}"></i>`
+        }))
     };
 }
 /**
  * Получить информацию о категории виджетов
  */
-export function getCategoryInfo(args) {
+export function getCategoryInfo(args = {}) {
     const { category } = args;
     if (!category) {
-        const categories = Object.keys(categorySettings);
         return {
-            available_categories: categories,
-            message: "Укажите category для получения детальной информации",
+            error: 'Не указана категория'
         };
     }
-    const categoryData = categorySettings[category];
+    const data = categorySettings;
+    const categoryData = data.categories?.[category];
     if (!categoryData) {
         return {
-            error: `Категория "${category}" не найдена`,
-            available_categories: Object.keys(categorySettings),
+            error: `Категория '${category}' не найдена`
         };
     }
     return {
         category,
-        libraries: categoryData.libraries,
-        common_settings: categoryData.commonSettings,
-        examples: categoryData.examples || [],
-        block_templates: (categoryBlockTemplates[category] || []).map((t) => t.handle),
+        ...categoryData
     };
 }
 /**
@@ -111,339 +97,79 @@ export function getCategoryInfo(args) {
  */
 export function getLibrariesInfo(args = {}) {
     const { category } = args;
+    const data = librariesRegistry;
+    let libraries = data.libraries || [];
     if (category) {
-        const categoryData = categorySettings[category];
-        if (!categoryData) {
-            return { error: `Категория "${category}" не найдена` };
-        }
-        const categoryLibraries = categoryData.libraries;
-        const librariesData = librariesRegistry.libraries || [];
-        const libraries = librariesData.filter((lib) => categoryLibraries.includes(lib.name));
-        return {
-            category,
-            libraries: libraries.map((lib) => ({
-                name: lib.name,
-                description: lib.description,
-                documentation: lib.documentation,
-            })),
-        };
+        libraries = libraries.filter((lib) => lib.category === category);
     }
-    const librariesData = librariesRegistry.libraries || [];
     return {
-        libraries: librariesData.map((lib) => ({
+        total: libraries.length,
+        libraries: libraries.map((lib) => ({
             name: lib.name,
+            handle: lib.handle,
             description: lib.description,
-            documentation: lib.documentation,
-            categories: lib.categories,
-        })),
+            category: lib.category,
+            type: lib.type,
+            usage: lib.usage
+        }))
     };
 }
-/**
- * Получить справочник Liquid переменных
- */
-export function getLiquidVariables(args = {}) {
-    const { category, search } = args;
-    const data = liquidVariables;
-    if (!category && !search) {
-        return {
-            categories: data.categories.map(cat => ({
-                name: cat.name,
-                count: cat.variables.length,
-            })),
-            total_variables: data.categories.reduce((sum, cat) => sum + cat.variables.length, 0),
-            message: "Укажите category или search для получения переменных",
-        };
-    }
-    if (category) {
-        const cat = data.categories.find(c => c.name.toLowerCase() === category.toLowerCase());
-        if (!cat) {
-            return {
-                error: `Категория "${category}" не найдена`,
-                available_categories: data.categories.map(c => c.name),
-            };
-        }
-        return {
-            category: cat.name,
-            count: cat.variables.length,
-            variables: cat.variables,
-        };
-    }
-    if (search) {
-        const searchLower = search.toLowerCase();
-        const results = [];
-        data.categories.forEach(cat => {
-            cat.variables.forEach(v => {
-                if (v.name.toLowerCase().includes(searchLower) ||
-                    v.description?.toLowerCase().includes(searchLower)) {
-                    results.push({
-                        ...v,
-                        category: cat.name,
-                    });
-                }
-            });
-        });
-        return {
-            search,
-            count: results.length,
-            variables: results,
-        };
-    }
-}
 /**
  * Получить справочник Liquid фильтров
  */
 export function getLiquidFilters(args = {}) {
     const { category, search } = args;
     const data = liquidFilters;
-    if (!category && !search) {
-        return {
-            categories: data.categories.map(cat => ({
-                name: cat.name,
-                count: cat.filters.length,
-            })),
-            total_filters: data.categories.reduce((sum, cat) => sum + cat.filters.length, 0),
-            message: "Укажите category или search для получения фильтров",
-        };
-    }
+    let filters = data.filters || [];
     if (category) {
-        const cat = data.categories.find(c => c.name.toLowerCase() === category.toLowerCase());
-        if (!cat) {
-            return {
-                error: `Категория "${category}" не найдена`,
-                available_categories: data.categories.map(c => c.name),
-            };
-        }
-        return {
-            category: cat.name,
-            count: cat.filters.length,
-            filters: cat.filters,
-        };
+        filters = filters.filter((filter) => filter.category === category);
     }
     if (search) {
         const searchLower = search.toLowerCase();
-        const results = [];
-        data.categories.forEach(cat => {
-            cat.filters.forEach(f => {
-                if (f.name.toLowerCase().includes(searchLower) ||
-                    f.description?.toLowerCase().includes(searchLower)) {
-                    results.push({
-                        ...f,
-                        category: cat.name,
-                    });
-                }
-            });
-        });
-        return {
-            search,
-            count: results.length,
-            filters: results,
-        };
+        filters = filters.filter((filter) => filter.name.toLowerCase().includes(searchLower) ||
+            filter.description?.toLowerCase().includes(searchLower));
     }
+    return {
+        total: filters.length,
+        categories: data.categories || [],
+        filters: filters.map((filter) => ({
+            name: filter.name,
+            description: filter.description,
+            category: filter.category,
+            syntax: filter.syntax,
+            examples: filter.examples
+        }))
+    };
 }
 /**
- * Получить справочник CommonJS API v2 для InSales
- * ОБНОВЛЕНО: использует commonjs-api-complete.json с акцентом на глобальные переменные
+ * Получить справочник CommonJS API
  */
 export function getCommonJSAPI(args = {}) {
     const { category, module, search } = args;
-    const completeData = commonjsApiComplete;
-    // Без параметров - критическая информация и обзор
-    if (!category && !module && !search) {
-        return {
-            version: completeData.version,
-            title: completeData.title,
-            description: completeData.description,
-            critical_info: completeData.critical_info,
-            installation: completeData.installation,
-            global_modules: Object.keys(completeData.global_modules).map(name => ({
-                name,
-                description: completeData.global_modules[name].description,
-                global_access: completeData.global_modules[name].global_access,
-                declarative: completeData.global_modules[name].declarative || false,
-                has_data_attributes: Object.keys(completeData.global_modules[name].data_attributes || {}).length > 0,
-                methods_count: Object.keys(completeData.global_modules[name].methods || {}).length,
-                events_count: Object.keys(completeData.global_modules[name].events || {}).length,
-            })),
-            ui_components: Object.keys(completeData.ui_components || {}).map(key => ({
-                name: completeData.ui_components[key].name,
-                description: completeData.ui_components[key].description,
-                declarative: completeData.ui_components[key].declarative,
-                no_js_needed: completeData.ui_components[key].no_js_needed,
-            })),
-            quick_reference: completeData.quick_reference,
-            message: "⚠️ ВСЕ модули доступны ГЛОБАЛЬНО! НЕ используйте import. Укажите module или search для детальной информации."
-        };
+    const data = commonjsApiComplete;
+    let modules = data.modules || [];
+    if (module) {
+        modules = modules.filter((mod) => mod.name === module);
     }
-    // Поиск по категории (для UI компонентов)
     if (category) {
-        const categoryMap = {
-            'product': ['Cart', 'Products', 'ajax_products', 'ajax_product', 'accessories'],
-            'cart': ['Cart'],
-            'lists': ['Compare', 'FavoritesProducts'],
-            'search': ['AjaxSearch'],
-            'forms': ['feedback_form', 'reviews_form', 'comments_form'],
-            'events': ['EventBus'],
-            'helpers': ['Shop', 'Template', 'ajaxAPI'],
-            'checkout': ['quick_checkout']
-        };
-        const modulesInCategory = categoryMap[category] || [];
-        const results = {
-            category,
-            global_modules: [],
-            ui_components: [],
-        };
-        modulesInCategory.forEach((modName) => {
-            if (completeData.global_modules[modName]) {
-                results.global_modules.push({
-                    name: modName,
-                    ...completeData.global_modules[modName]
-                });
-            }
-            if (completeData.ui_components[modName]) {
-                results.ui_components.push({
-                    key: modName,
-                    ...completeData.ui_components[modName]
-                });
-            }
-        });
-        return results;
-    }
-    // Поиск по модулю
-    if (module) {
-        // Сначала ищем в глобальных модулях
-        if (completeData.global_modules[module]) {
-            const mod = completeData.global_modules[module];
-            return {
-                type: 'global_module',
-                name: module,
-                ...mod,
-                usage_note: mod.declarative ?
-                    "💡 Этот модуль поддерживает декларативную работу через data-атрибуты. Используйте их вместо JavaScript где возможно." :
-                    "⚠️ Этот модуль требует JavaScript для работы.",
-                best_practices: completeData.best_practices,
-            };
-        }
-        // Затем ищем в UI компонентах
-        if (completeData.ui_components[module]) {
-            const comp = completeData.ui_components[module];
-            return {
-                type: 'ui_component',
-                key: module,
-                ...comp,
-                usage_note: comp.no_js_needed ?
-                    "✅ Этот компонент работает ПОЛНОСТЬЮ без JavaScript!" :
-                    "⚠️ Этот компонент требует инициализации через JavaScript.",
-            };
-        }
-        return {
-            error: `Модуль "${module}" не найден`,
-            available_global_modules: Object.keys(completeData.global_modules),
-            available_ui_components: Object.keys(completeData.ui_components || {}),
-        };
+        modules = modules.filter((mod) => mod.category === category);
     }
-    // Поиск по ключевому слову
     if (search) {
         const searchLower = search.toLowerCase();
-        const results = {
-            global_modules: [],
-            data_attributes: [],
-            methods: [],
-            events: [],
-            ui_components: [],
-            patterns: [],
-        };
-        // Поиск в глобальных модулях
-        Object.entries(completeData.global_modules).forEach(([name, mod]) => {
-            // Поиск по имени и описанию модуля
-            if (name.toLowerCase().includes(searchLower) ||
-                mod.description?.toLowerCase().includes(searchLower)) {
-                results.global_modules.push({
-                    name,
-                    description: mod.description,
-                    global_access: mod.global_access,
-                    declarative: mod.declarative,
-                });
-            }
-            // Поиск по data-атрибутам
-            if (mod.data_attributes) {
-                Object.entries(mod.data_attributes).forEach(([attrName, attr]) => {
-                    if (attrName.toLowerCase().includes(searchLower) ||
-                        attr.description?.toLowerCase().includes(searchLower)) {
-                        results.data_attributes.push({
-                            name: attrName,
-                            module: name,
-                            ...attr,
-                        });
-                    }
-                });
-            }
-            // Поиск по методам
-            if (mod.methods) {
-                Object.entries(mod.methods).forEach(([methodName, method]) => {
-                    if (methodName.toLowerCase().includes(searchLower) ||
-                        method.description?.toLowerCase().includes(searchLower)) {
-                        results.methods.push({
-                            name: methodName,
-                            module: name,
-                            ...method,
-                        });
-                    }
-                });
-            }
-            // Поиск по событиям
-            if (mod.events) {
-                Object.entries(mod.events).forEach(([eventName, event]) => {
-                    if (eventName.toLowerCase().includes(searchLower) ||
-                        event.description?.toLowerCase().includes(searchLower)) {
-                        results.events.push({
-                            name: eventName,
-                            module: name,
-                            ...event,
-                        });
-                    }
-                });
-            }
-        });
-        // Поиск в UI компонентах
-        if (completeData.ui_components) {
-            Object.entries(completeData.ui_components).forEach(([key, comp]) => {
-                if (key.toLowerCase().includes(searchLower) ||
-                    comp.name?.toLowerCase().includes(searchLower) ||
-                    comp.description?.toLowerCase().includes(searchLower)) {
-                    results.ui_components.push({
-                        key,
-                        ...comp,
-                    });
-                }
-            });
-        }
-        // Поиск в паттернах
-        if (completeData.common_patterns) {
-            Object.entries(completeData.common_patterns).forEach(([key, pattern]) => {
-                if (key.toLowerCase().includes(searchLower) ||
-                    pattern.title?.toLowerCase().includes(searchLower)) {
-                    results.patterns.push({
-                        key,
-                        ...pattern,
-                    });
-                }
-            });
-        }
-        const totalResults = results.global_modules.length +
-            results.data_attributes.length +
-            results.methods.length +
-            results.events.length +
-            results.ui_components.length +
-            results.patterns.length;
-        return {
-            search,
-            total_results: totalResults,
-            results,
-            note: totalResults === 0 ?
-                "Ничего не найдено. Попробуйте другой запрос или используйте module для просмотра конкретного модуля." :
-                `Найдено ${totalResults} результатов. Используйте data-атрибуты вместо JavaScript где возможно!`,
-        };
+        modules = modules.filter((mod) => mod.name.toLowerCase().includes(searchLower) ||
+            mod.description?.toLowerCase().includes(searchLower) ||
+            mod.methods?.some((m) => m.name.toLowerCase().includes(searchLower)));
     }
+    return {
+        total: modules.length,
+        modules: modules.map((mod) => ({
+            name: mod.name,
+            description: mod.description,
+            category: mod.category,
+            methods: mod.methods || [],
+            events: mod.events || []
+        }))
+    };
 }
 /**
  * Получить паттерны меню категорий
@@ -451,207 +177,133 @@ export function getCommonJSAPI(args = {}) {
 export function getCollectionsMenuPatterns(args = {}) {
     const { patternId, category } = args;
     const data = collectionsMenuPatterns;
-    // Без параметров - общая информация
-    if (!patternId && !category) {
-        return {
-            title: data.title,
-            description: data.description,
-            patterns: data.patterns.map((p) => ({
-                id: p.id,
-                name: p.name,
-                description: p.description,
-                useCase: p.useCase,
-                structure: p.structure,
-                features: p.features,
-            })),
-            total_patterns: data.patterns.length,
-            message: "Укажите patternId для получения полного кода паттерна",
-        };
-    }
-    // Поиск конкретного паттерна
+    let patterns = data.patterns || [];
     if (patternId) {
-        const pattern = data.patterns.find((p) => p.id === patternId);
-        if (!pattern) {
+        const pattern = patterns.find((p) => p.id === patternId);
+        if (pattern) {
             return {
-                error: `Паттерн "${patternId}" не найден`,
-                available_patterns: data.patterns.map((p) => p.id),
+                pattern: {
+                    id: pattern.id,
+                    name: pattern.name,
+                    description: pattern.description,
+                    category: pattern.category,
+                    code: pattern.code,
+                    settings: pattern.settings
+                }
             };
         }
-        return {
-            pattern: {
-                id: pattern.id,
-                name: pattern.name,
-                description: pattern.description,
-                useCase: pattern.useCase,
-                structure: pattern.structure,
-                cacheKeyPattern: pattern.cacheKeyPattern,
-                requiredSettings: pattern.requiredSettings,
-                liquidCode: pattern.liquidCode,
-                features: pattern.features,
-            },
-            commonPatterns: data.commonPatterns,
-            collectionMethods: data.collectionMethods,
-            dataAttributes: data.dataAttributes,
-            bestPractices: data.bestPractices,
-        };
+        return { error: `Паттерн '${patternId}' не найден` };
     }
-    // Фильтрация по категории (по useCase)
     if (category) {
-        const categoryLower = category.toLowerCase();
-        const matchingPatterns = data.patterns.filter((p) => p.useCase.toLowerCase().includes(categoryLower) ||
-            p.description.toLowerCase().includes(categoryLower));
-        return {
-            category,
-            count: matchingPatterns.length,
-            patterns: matchingPatterns.map((p) => ({
-                id: p.id,
-                name: p.name,
-                description: p.description,
-                useCase: p.useCase,
-                structure: p.structure,
-                features: p.features,
-            })),
-        };
+        patterns = patterns.filter((pattern) => pattern.category === category);
     }
+    return {
+        total: patterns.length,
+        patterns: patterns.map((pattern) => ({
+            id: pattern.id,
+            name: pattern.name,
+            description: pattern.description,
+            category: pattern.category
+        }))
+    };
 }
 /**
- * Получить справочник API библиотек
- * Объединяет информацию из libraries-registry и libraries-api-reference
+ * Получить API библиотек
  */
 export function getLibrariesAPI(args = {}) {
     const { library, search, category } = args;
-    const apiData = librariesApiReference;
-    const registryData = librariesRegistry;
-    // Без параметров - список всех библиотек с API документацией
-    if (!library && !search && !category) {
-        return {
-            title: apiData.title,
-            description: apiData.description,
-            libraries_with_api: apiData.libraries.map((lib) => ({
-                name: lib.name,
-                handle: lib.handle,
-                type: lib.type,
-                description: lib.description,
-                dependencies: lib.dependencies,
-                categories: lib.categories,
-            })),
-            total_libraries: apiData.libraries.length,
-            message: "Укажите library для получения полной документации по API, или search для поиска",
-            available_libraries: apiData.libraries.map((lib) => lib.handle),
-        };
-    }
-    // Поиск конкретной библиотеки
+    const data = librariesApiReference;
+    let libraries = data.libraries || [];
     if (library) {
-        const lib = apiData.libraries.find((l) => l.handle === library || l.name.toLowerCase() === library.toLowerCase());
-        if (!lib) {
+        const lib = libraries.find((l) => l.handle === library || l.name === library);
+        if (lib) {
             return {
-                error: `Библиотека "${library}" не найдена в API справочнике`,
-                available_libraries: apiData.libraries.map((l) => ({
-                    handle: l.handle,
-                    name: l.name,
-                })),
-                note: "Некоторые библиотеки могут не иметь подробной API документации",
-            };
-        }
-        // Полная информация о библиотеке
-        return {
-            library: {
-                name: lib.name,
-                handle: lib.handle,
-                version: lib.version,
-                type: lib.type,
-                description: lib.description,
-                categories: lib.categories,
-                dependencies: lib.dependencies,
-            },
-            usage: lib.usage,
-            options: lib.options,
-            methods: lib.methods,
-            events: lib.events,
-            cssClasses: lib.cssClasses,
-            examples: lib.examples,
-            bestPractices: lib.bestPractices,
-            notes: lib.notes,
-        };
-    }
-    // Поиск по ключевому слову
-    if (search) {
-        const searchLower = search.toLowerCase();
-        const results = {
-            libraries: [],
-            options: [],
-            methods: [],
-            examples: [],
-        };
-        apiData.libraries.forEach((lib) => {
-            // Поиск по библиотекам
-            if (lib.name.toLowerCase().includes(searchLower) ||
-                lib.handle.toLowerCase().includes(searchLower) ||
-                lib.description?.toLowerCase().includes(searchLower)) {
-                results.libraries.push({
+                library: {
                     name: lib.name,
                     handle: lib.handle,
                     description: lib.description,
                     type: lib.type,
-                });
-            }
-            // Поиск по опциям
-            lib.options?.forEach((opt) => {
-                if (opt.name.toLowerCase().includes(searchLower) ||
-                    opt.description?.toLowerCase().includes(searchLower)) {
-                    results.options.push({
-                        ...opt,
-                        library: lib.name,
-                        library_handle: lib.handle,
-                    });
-                }
-            });
-            // Поиск по методам
-            lib.methods?.forEach((method) => {
-                if (method.name.toLowerCase().includes(searchLower) ||
-                    method.description?.toLowerCase().includes(searchLower)) {
-                    results.methods.push({
-                        ...method,
-                        library: lib.name,
-                        library_handle: lib.handle,
-                    });
+                    category: lib.category,
+                    options: lib.options || [],
+                    methods: lib.methods || [],
+                    examples: lib.examples || []
                 }
-            });
-            // Поиск по примерам
-            lib.examples?.forEach((example) => {
-                if (example.title?.toLowerCase().includes(searchLower) ||
-                    example.description?.toLowerCase().includes(searchLower)) {
-                    results.examples.push({
-                        ...example,
-                        library: lib.name,
-                        library_handle: lib.handle,
-                    });
-                }
-            });
-        });
-        return {
-            search,
-            libraries_count: results.libraries.length,
-            options_count: results.options.length,
-            methods_count: results.methods.length,
-            examples_count: results.examples.length,
-            results,
-        };
+            };
+        }
+        return { error: `Библиотека '${library}' не найдена` };
     }
-    // Фильтрация по категории
     if (category) {
-        const categoryLibraries = apiData.libraries.filter((lib) => lib.categories?.includes(category));
-        return {
-            category,
-            count: categoryLibraries.length,
-            libraries: categoryLibraries.map((lib) => ({
-                name: lib.name,
-                handle: lib.handle,
-                description: lib.description,
-                type: lib.type,
-                usage: lib.usage,
-            })),
-        };
+        libraries = libraries.filter((lib) => lib.category === category);
+    }
+    if (search) {
+        const searchLower = search.toLowerCase();
+        libraries = libraries.filter((lib) => lib.name.toLowerCase().includes(searchLower) ||
+            lib.handle.toLowerCase().includes(searchLower) ||
+            lib.description?.toLowerCase().includes(searchLower));
     }
+    return {
+        total: libraries.length,
+        libraries: libraries.map((lib) => ({
+            name: lib.name,
+            handle: lib.handle,
+            description: lib.description,
+            type: lib.type,
+            category: lib.category
+        }))
+    };
+}
+/**
+ * Получить справочник Liquid переменных
+ */
+export function getLiquidVariables(args = {}) {
+    const { category, search } = args;
+    const data = liquidVariables;
+    let variables = data.variables || [];
+    if (category) {
+        variables = variables.filter((variable) => variable.category === category);
+    }
+    if (search) {
+        const searchLower = search.toLowerCase();
+        variables = variables.filter((variable) => variable.name.toLowerCase().includes(searchLower) ||
+            variable.description?.toLowerCase().includes(searchLower));
+    }
+    return {
+        total: variables.length,
+        categories: data.categories || [],
+        variables: variables.map((variable) => ({
+            name: variable.name,
+            description: variable.description,
+            category: variable.category,
+            type: variable.type,
+            examples: variable.examples
+        }))
+    };
+}
+/**
+ * Получить постоянные ссылки InSales
+ */
+export function getInsalesPermanentLinks(args = {}) {
+    const { search } = args;
+    const data = insalesPermanentLinks;
+    let links = data.links || {};
+    if (search) {
+        const searchLower = search.toLowerCase();
+        const filteredLinks = {};
+        Object.keys(links).forEach(key => {
+            const link = links[key];
+            if (key.toLowerCase().includes(searchLower) ||
+                link.description?.toLowerCase().includes(searchLower) ||
+                link.usage?.toLowerCase().includes(searchLower)) {
+                filteredLinks[key] = link;
+            }
+        });
+        links = filteredLinks;
+    }
+    return {
+        description: data.description,
+        total: Object.keys(links).length,
+        links,
+        notes: data.notes
+    };
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iwgt",
-  "version": "2.4.9",
+  "version": "2.4.10",
   "description": "MCP server",
   "type": "module",
   "main": "dist/index.js",