iwgt 2.4.7 → 2.4.10

package/dist/tools/index.js

@@ -9,8 +9,10 @@ import categorySettings from '../data/references/category-settings.json' with {
 import librariesRegistry from '../data/references/libraries-registry.json' with { type: 'json' };
 import liquidVariables from '../data/references/liquid-variables.json' with { type: 'json' };
 import liquidFilters from '../data/references/liquid-filters.json' with { type: 'json' };
-import commonjsReference from '../data/references/commonjs-reference.json' with { type: 'json' };
+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' };
 /**
  * Получить список блок-темплейтов с фильтрацией
  */
@@ -30,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
+        }))
     };
 }
 /**
@@ -49,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();
@@ -63,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
     };
 }
 /**
@@ -110,253 +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
  */
 export function getCommonJSAPI(args = {}) {
     const { category, module, search } = args;
-    const data = commonjsReference;
-    // Без параметров - общая информация
-    if (!category && !module && !search) {
-        return {
-            modules: data.modules.map(m => ({
-                name: m.name,
-                description: m.description,
-                methods_count: m.methods?.length || 0,
-                events_count: m.events?.length || 0,
-            })),
-            total_modules: data.modules.length,
-            total_methods: data.modules.reduce((sum, m) => sum + (m.methods?.length || 0), 0),
-            total_events: data.modules.reduce((sum, m) => sum + (m.events?.length || 0), 0),
-            message: "Укажите module или search для детальной информации",
-        };
+    const data = commonjsApiComplete;
+    let modules = data.modules || [];
+    if (module) {
+        modules = modules.filter((mod) => mod.name === module);
     }
-    // Поиск по категории (не используется в CommonJS)
     if (category) {
-        // CommonJS не имеет категорий, игнорируем
-        const modules = data.modules;
-        return {
-            category,
-            modules: modules.map(m => ({
-                name: m.name,
-                description: m.description,
-                methods: m.methods,
-                attributes: m.attributes,
-                events: m.events,
-            })),
-        };
-    }
-    // Поиск по модулю
-    if (module) {
-        const mod = data.modules.find(m => m.name === module);
-        if (!mod) {
-            return {
-                error: `Модуль "${module}" не найден`,
-                available_modules: data.modules.map(m => m.name),
-            };
-        }
-        return {
-            module: mod.name,
-            description: mod.description,
-            methods: mod.methods,
-            attributes: mod.attributes,
-            events: mod.events,
-            examples: mod.examples,
-        };
+        modules = modules.filter((mod) => mod.category === category);
     }
-    // Поиск по ключевому слову
     if (search) {
         const searchLower = search.toLowerCase();
-        const results = {
-            methods: [],
-            events: [],
-            attributes: [],
-            method_events: [], // События, связанные с методами
-        };
-        data.modules.forEach(mod => {
-            // Поиск по методам
-            mod.methods?.forEach(method => {
-                if (method.name.toLowerCase().includes(searchLower) ||
-                    method.description?.toLowerCase().includes(searchLower)) {
-                    results.methods.push({
-                        ...method,
-                        module: mod.name,
-                    });
-                }
-                // Поиск по событиям внутри методов
-                method.events?.forEach(event => {
-                    if (event.name.toLowerCase().includes(searchLower) ||
-                        event.description?.toLowerCase().includes(searchLower)) {
-                        results.method_events.push({
-                            ...event,
-                            module: mod.name,
-                            method: method.name,
-                        });
-                    }
-                });
-            });
-            // Поиск по событиям модуля
-            mod.events?.forEach(event => {
-                if (event.name.toLowerCase().includes(searchLower) ||
-                    event.description?.toLowerCase().includes(searchLower)) {
-                    results.events.push({
-                        ...event,
-                        module: mod.name,
-                    });
-                }
-            });
-            // Поиск по атрибутам
-            mod.attributes?.forEach(attr => {
-                if (attr.name.toLowerCase().includes(searchLower) ||
-                    attr.description?.toLowerCase().includes(searchLower)) {
-                    results.attributes.push({
-                        ...attr,
-                        module: mod.name,
-                    });
-                }
-            });
-        });
-        return {
-            search,
-            methods_count: results.methods.length,
-            events_count: results.events.length,
-            method_events_count: results.method_events.length,
-            attributes_count: results.attributes.length,
-            note: results.attributes.length > 0
-                ? 'Data-атрибуты работают автоматически при добавлении в HTML. JavaScript не требуется для базовой функциональности.'
-                : undefined,
-            results,
-        };
+        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 || []
+        }))
+    };
 }
 /**
  * Получить паттерны меню категорий
@@ -364,67 +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 библиотек
+ */
+export function getLibrariesAPI(args = {}) {
+    const { library, search, category } = args;
+    const data = librariesApiReference;
+    let libraries = data.libraries || [];
+    if (library) {
+        const lib = libraries.find((l) => l.handle === library || l.name === library);
+        if (lib) {
+            return {
+                library: {
+                    name: lib.name,
+                    handle: lib.handle,
+                    description: lib.description,
+                    type: lib.type,
+                    category: lib.category,
+                    options: lib.options || [],
+                    methods: lib.methods || [],
+                    examples: lib.examples || []
+                }
+            };
+        }
+        return { error: `Библиотека '${library}' не найдена` };
+    }
+    if (category) {
+        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.7",
+  "version": "2.4.10",
   "description": "MCP server",
   "type": "module",
   "main": "dist/index.js",