@maxisoft/instantcms-mcp 1.2.3

package/dist/tools/project-patch-tool.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectPatch = createProjectPatch;
+function splitLines(content) {
+    if (!content)
+        return [];
+    const lines = content.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    return lines;
+}
+function patchBody(oldContent, newContent) {
+    const oldLines = splitLines(oldContent);
+    const newLines = splitLines(newContent);
+    const removed = oldLines.map(line => `-${line}`);
+    const added = newLines.map(line => `+${line}`);
+    if (oldContent && !oldContent.endsWith('\n'))
+        removed.push('\');
+    if (newContent && !newContent.endsWith('\n'))
+        added.push('\');
+    return [
+        `@@ -${oldLines.length ? `1,${oldLines.length}` : '0,0'} +${newLines.length ? `1,${newLines.length}` : '0,0'} @@`,
+        ...removed,
+        ...added,
+    ];
+}
+function header(path) {
+    const normalized = path.replace(/\\/g, '/').replace(/^\.\//, '');
+    if (!normalized ||
+        normalized.startsWith('/') ||
+        /[\r\n\0]/.test(normalized) ||
+        normalized.split('/').some(part => part === '..')) {
+        throw new Error(`Unsafe project path: ${path}`);
+    }
+    return normalized;
+}
+function createProjectPatch(beforeInput, afterInput) {
+    const before = Object.fromEntries(Object.entries(beforeInput).map(([path, value]) => [header(path), value]));
+    const after = Object.fromEntries(Object.entries(afterInput).map(([path, value]) => [header(path), value]));
+    const removed = Object.keys(before).filter(path => !(path in after));
+    const added = Object.keys(after).filter(path => !(path in before));
+    const renamed = new Map();
+    for (const oldPath of removed) {
+        const newPath = added.find(path => ![...renamed.values()].includes(path) && after[path] === before[oldPath]);
+        if (newPath)
+            renamed.set(oldPath, newPath);
+    }
+    const chunks = [];
+    for (const [oldPath, newPath] of [...renamed].sort(([a], [b]) => a.localeCompare(b))) {
+        chunks.push(`diff --git a/${oldPath} b/${newPath}`, 'similarity index 100%', `rename from ${oldPath}`, `rename to ${newPath}`);
+    }
+    for (const path of removed.filter(item => !renamed.has(item)).sort()) {
+        chunks.push(`diff --git a/${path} b/${path}`, 'deleted file mode 100644', `--- a/${path}`, '+++ /dev/null', ...patchBody(before[path], ''));
+    }
+    for (const path of added.filter(item => ![...renamed.values()].includes(item)).sort()) {
+        chunks.push(`diff --git a/${path} b/${path}`, 'new file mode 100644', '--- /dev/null', `+++ b/${path}`, ...patchBody('', after[path]));
+    }
+    for (const path of Object.keys(before)
+        .filter(path => path in after && before[path] !== after[path])
+        .sort()) {
+        chunks.push(`diff --git a/${path} b/${path}`, `--- a/${path}`, `+++ b/${path}`, ...patchBody(before[path], after[path]));
+    }
+    const patch = chunks.length ? `${chunks.join('\n')}\n` : '';
+    return {
+        patch,
+        changed_files: removed.length +
+            added.length -
+            renamed.size +
+            Object.keys(before).filter(path => path in after && before[path] !== after[path]).length,
+        renames: Object.fromEntries(renamed),
+        is_empty: !patch,
+    };
+}

package/dist/tools/project-source-tool.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadLocalProject = loadLocalProject;
+exports.loadGithubProject = loadGithubProject;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const fflate_1 = require("fflate");
+const DEFAULT_MAX_FILES = 2000;
+const DEFAULT_MAX_FILE_BYTES = 1024 * 1024;
+const DEFAULT_MAX_TOTAL_BYTES = 20 * 1024 * 1024;
+const ignoredDirectories = new Set(['.git', 'node_modules', 'vendor', 'dist', 'build', '.idea']);
+const textExtensions = new Set([
+    '.css',
+    '.html',
+    '.ini',
+    '.js',
+    '.json',
+    '.md',
+    '.php',
+    '.scss',
+    '.sql',
+    '.svg',
+    '.tpl',
+    '.ts',
+    '.tsx',
+    '.txt',
+    '.xml',
+    '.yaml',
+    '.yml',
+]);
+function limits(options) {
+    return {
+        maxFiles: options.max_files ?? DEFAULT_MAX_FILES,
+        maxFileBytes: options.max_file_bytes ?? DEFAULT_MAX_FILE_BYTES,
+        maxTotalBytes: options.max_total_bytes ?? DEFAULT_MAX_TOTAL_BYTES,
+    };
+}
+function isTextFile(path, bytes) {
+    const extension = path.includes('.') ? path.slice(path.lastIndexOf('.')).toLowerCase() : '';
+    if (textExtensions.has(extension) ||
+        ['LICENSE', 'README', '.gitignore'].includes(path.split('/').at(-1) ?? '')) {
+        return !bytes.subarray(0, 8192).includes(0);
+    }
+    return false;
+}
+function assertWithinRoot(root, candidate) {
+    if (candidate !== root && !candidate.startsWith(`${root}${node_path_1.sep}`)) {
+        throw new Error(`Path escapes the requested project root: ${candidate}`);
+    }
+}
+async function loadLocalProject(rootInput, options = {}) {
+    const root = await (0, promises_1.realpath)((0, node_path_1.resolve)(rootInput));
+    if (!(await (0, promises_1.lstat)(root)).isDirectory())
+        throw new Error('Local project path must be a directory');
+    const configured = limits(options);
+    const files = {};
+    const skipped = [];
+    let totalBytes = 0;
+    async function walk(directory) {
+        assertWithinRoot(root, directory);
+        for (const entry of await (0, promises_1.readdir)(directory, { withFileTypes: true })) {
+            if (entry.isSymbolicLink()) {
+                skipped.push({
+                    path: (0, node_path_1.relative)(root, (0, node_path_1.resolve)(directory, entry.name)),
+                    reason: 'symbolic_link',
+                });
+                continue;
+            }
+            if (entry.isDirectory() && ignoredDirectories.has(entry.name))
+                continue;
+            const absolute = (0, node_path_1.resolve)(directory, entry.name);
+            assertWithinRoot(root, absolute);
+            if (entry.isDirectory()) {
+                await walk(absolute);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const path = (0, node_path_1.relative)(root, absolute).split(node_path_1.sep).join('/');
+            const bytes = await (0, promises_1.readFile)(absolute);
+            if (bytes.byteLength > configured.maxFileBytes) {
+                skipped.push({ path, reason: 'file_too_large' });
+                continue;
+            }
+            if (!isTextFile(path, bytes)) {
+                skipped.push({ path, reason: 'binary_or_unsupported' });
+                continue;
+            }
+            if (Object.keys(files).length >= configured.maxFiles)
+                throw new Error('Project file limit exceeded');
+            totalBytes += bytes.byteLength;
+            if (totalBytes > configured.maxTotalBytes)
+                throw new Error('Project total size limit exceeded');
+            files[path] = bytes.toString('utf8');
+        }
+    }
+    await walk(root);
+    return {
+        source: 'local',
+        root,
+        files,
+        files_loaded: Object.keys(files).length,
+        total_bytes: totalBytes,
+        skipped,
+    };
+}
+function validateGithubPart(value, label) {
+    if (!/^[A-Za-z0-9._/-]+$/.test(value) || value.includes('..') || value.startsWith('/')) {
+        throw new Error(`Invalid GitHub ${label}`);
+    }
+    return value;
+}
+async function loadGithubProject(repository, ref = 'main', subpath = '', options = {}) {
+    const match = repository.match(/^(?:https:\/\/github\.com\/)?([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?\/?$/);
+    if (!match)
+        throw new Error('Repository must be owner/name or an https://github.com/owner/name URL');
+    const owner = validateGithubPart(match[1], 'owner');
+    const name = validateGithubPart(match[2], 'repository');
+    const safeRef = validateGithubPart(ref, 'ref');
+    const safeSubpath = subpath
+        ? validateGithubPart(subpath.replace(/^\.\//, '').replace(/\/$/, ''), 'subpath')
+        : '';
+    const response = await fetch(`https://codeload.github.com/${owner}/${name}/zip/${encodeURIComponent(safeRef)}`, { headers: { 'user-agent': 'instantcms-mcp' }, redirect: 'error' });
+    if (!response.ok)
+        throw new Error(`GitHub archive request failed: HTTP ${response.status}`);
+    const contentLength = Number(response.headers.get('content-length') ?? 0);
+    if (contentLength > 50 * 1024 * 1024)
+        throw new Error('GitHub archive is too large');
+    const archive = new Uint8Array(await response.arrayBuffer());
+    if (archive.byteLength > 50 * 1024 * 1024)
+        throw new Error('GitHub archive is too large');
+    const configured = limits(options);
+    const archiveRelativePath = (archivePath) => {
+        const parts = archivePath.split('/').slice(1);
+        if (!parts.length || archivePath.endsWith('/'))
+            return null;
+        const path = parts.join('/');
+        if (safeSubpath && path !== safeSubpath && !path.startsWith(`${safeSubpath}/`))
+            return null;
+        const relativePath = safeSubpath ? path.slice(safeSubpath.length).replace(/^\//, '') : path;
+        if (!relativePath || relativePath.split('/').some(part => ignoredDirectories.has(part)))
+            return null;
+        return relativePath;
+    };
+    let projectedFiles = 0;
+    let projectedBytes = 0;
+    const entries = (0, fflate_1.unzipSync)(archive, {
+        filter: file => {
+            if (!archiveRelativePath(file.name) || file.originalSize > configured.maxFileBytes)
+                return false;
+            projectedFiles += 1;
+            projectedBytes += file.originalSize;
+            if (projectedFiles > configured.maxFiles)
+                throw new Error('Project file limit exceeded');
+            if (projectedBytes > configured.maxTotalBytes)
+                throw new Error('Project total size limit exceeded');
+            return true;
+        },
+    });
+    const files = {};
+    const skipped = [];
+    let totalBytes = 0;
+    for (const [archivePath, bytes] of Object.entries(entries)) {
+        const relativePath = archiveRelativePath(archivePath);
+        if (!relativePath)
+            continue;
+        if (!isTextFile(relativePath, bytes)) {
+            skipped.push({ path: relativePath, reason: 'binary_or_unsupported' });
+            continue;
+        }
+        if (Object.keys(files).length >= configured.maxFiles)
+            throw new Error('Project file limit exceeded');
+        totalBytes += bytes.byteLength;
+        if (totalBytes > configured.maxTotalBytes)
+            throw new Error('Project total size limit exceeded');
+        files[relativePath] = Buffer.from(bytes).toString('utf8');
+    }
+    return {
+        source: 'github',
+        repository: `${owner}/${name}`,
+        ref: safeRef,
+        subpath: safeSubpath,
+        files,
+        files_loaded: Object.keys(files).length,
+        total_bytes: totalBytes,
+        skipped,
+    };
+}

package/dist/tools/project-workflow-tool.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditInstantCmsProject = auditInstantCmsProject;
+exports.planProjectChanges = planProjectChanges;
+exports.repairInstantCmsProject = repairInstantCmsProject;
+exports.explainInstantCmsProject = explainInstantCmsProject;
+exports.planInstantCmsUpgrade = planInstantCmsUpgrade;
+const addon_tool_js_1 = require("./addon-tool.js");
+const artifact_tool_js_1 = require("./artifact-tool.js");
+const version_profiles_js_1 = require("../data/version-profiles.js");
+const components_js_1 = require("../data/components.js");
+const hooks_js_1 = require("../data/hooks.js");
+const project_patch_tool_js_1 = require("./project-patch-tool.js");
+function normalizeFiles(files) {
+    return Object.fromEntries(Object.entries(files).map(([filePath, content]) => [
+        filePath.replace(/\\/g, '/').replace(/^\.\//, ''),
+        content,
+    ]));
+}
+function projectKind(files) {
+    const paths = Object.keys(files);
+    if (paths.some(file => /(?:^|\/)manifest\.xml$/.test(file)))
+        return 'addon';
+    if (paths.some(file => /(?:^|\/)widgets?\//.test(file)))
+        return 'widget';
+    if (paths.some(file => /(?:^|\/)templates?\//.test(file)))
+        return 'template';
+    return 'unknown';
+}
+function securityDiagnostics(files) {
+    const diagnostics = [];
+    for (const [filePath, content] of Object.entries(files)) {
+        if (!filePath.endsWith('.php'))
+            continue;
+        if (/->query\(\s*["'`][^"'`]*\$[a-z_]/i.test(content)) {
+            diagnostics.push({
+                code: 'POSSIBLE_SQL_INTERPOLATION',
+                severity: 'warning',
+                path: filePath,
+                message: 'SQL-запрос содержит интерполяцию переменной.',
+                suggestion: 'Используйте query builder или параметризованный запрос.',
+            });
+        }
+        if (/\becho\s+\$(?:_GET|_POST|_REQUEST|[a-z_]\w*)\s*;/i.test(content)) {
+            diagnostics.push({
+                code: 'POSSIBLE_UNESCAPED_OUTPUT',
+                severity: 'warning',
+                path: filePath,
+                message: 'Переменная выводится без видимого контекстного экранирования.',
+                suggestion: 'Проверьте происхождение значения и примените HTML escaping в шаблоне.',
+            });
+        }
+        if (/class\s+\w+\s+extends\s+cmsGrid\b/.test(content)) {
+            diagnostics.push({
+                code: 'LEGACY_CMSGRID_CLASS',
+                severity: 'error',
+                path: filePath,
+                message: 'Backend grid должен быть функцией grid_*, а не классом cmsGrid.',
+                suggestion: 'Перенесите конфигурацию в функцию backend/grids/grid_*.php.',
+            });
+        }
+    }
+    return diagnostics;
+}
+function pathDiagnostics(files) {
+    return Object.keys(files).flatMap(filePath => {
+        if (/controllers\/[^/]+\/languages\//.test(filePath)) {
+            return [
+                {
+                    code: 'MISPLACED_LANGUAGE_FILE',
+                    severity: 'error',
+                    path: filePath,
+                    message: 'Language files должны находиться вне каталога контроллера.',
+                    suggestion: 'Переместите файл в system/languages/{lang}/controllers/{name}/.',
+                },
+            ];
+        }
+        return [];
+    });
+}
+function auditInstantCmsProject(filesInput) {
+    const files = normalizeFiles(filesInput);
+    const kind = projectKind(files);
+    const artifact = (0, artifact_tool_js_1.validateGeneratedArtifacts)(files);
+    const addon = kind === 'addon' ? (0, addon_tool_js_1.validateAddon)(files) : null;
+    const addonDiagnostics = addon
+        ? (addon.diagnostics ?? [])
+            .filter((item) => item.severity === 'error' || item.severity === 'warning')
+            .map(item => ({ ...item, path: item.path ?? '' }))
+        : [];
+    const diagnostics = [
+        ...artifact.diagnostics,
+        ...addonDiagnostics,
+        ...pathDiagnostics(files),
+        ...securityDiagnostics(files),
+    ];
+    return {
+        kind,
+        files_checked: Object.keys(files).length,
+        is_valid: !diagnostics.some(item => item.severity === 'error'),
+        summary: {
+            errors: diagnostics.filter(item => item.severity === 'error').length,
+            warnings: diagnostics.filter(item => item.severity === 'warning').length,
+        },
+        diagnostics,
+    };
+}
+function planProjectChanges(files) {
+    const audit = auditInstantCmsProject(files);
+    const operations = audit.diagnostics.map(diagnostic => ({
+        kind: diagnostic.code === 'MISPLACED_LANGUAGE_FILE' ? 'move' : 'review',
+        path: diagnostic.path,
+        target: diagnostic.code === 'MISPLACED_LANGUAGE_FILE'
+            ? diagnostic.path.replace(/controllers\/([^/]+)\/languages\/([^/]+)\//, 'languages/$2/controllers/$1/')
+            : undefined,
+        reason: diagnostic.suggestion ?? diagnostic.message,
+        safe: diagnostic.code === 'MISPLACED_LANGUAGE_FILE',
+    }));
+    return { audit, operations, safe_operations: operations.filter(item => item.safe).length };
+}
+function repairInstantCmsProject(filesInput) {
+    const before = normalizeFiles(filesInput);
+    const files = { ...before };
+    const plan = planProjectChanges(files);
+    const applied = [];
+    for (const operation of plan.operations) {
+        if (operation.kind !== 'move' || !operation.safe || !operation.target)
+            continue;
+        if (!(operation.path in files) || operation.target in files)
+            continue;
+        files[operation.target] = files[operation.path];
+        delete files[operation.path];
+        applied.push(operation);
+    }
+    return {
+        files,
+        applied,
+        patch: (0, project_patch_tool_js_1.createProjectPatch)(before, files),
+        remaining: auditInstantCmsProject(files),
+    };
+}
+function explainInstantCmsProject(files) {
+    const normalized = normalizeFiles(files);
+    const paths = Object.keys(normalized);
+    return {
+        kind: projectKind(normalized),
+        files: paths.length,
+        controllers: [...new Set(paths.flatMap(path => path.match(/controllers\/([^/]+)/)?.[1] ?? []))],
+        hooks: paths.filter(path => /\/hooks\/[^/]+\.php$/.test(path)),
+        actions: paths.filter(path => /\/actions\/[^/]+\.php$/.test(path)),
+        forms: paths.filter(path => /\/forms\/[^/]+\.php$/.test(path)),
+        templates: paths.filter(path => /\.tpl\.php$/.test(path)),
+        languages: paths.filter(path => /(?:^|\/)languages\//.test(path)),
+    };
+}
+function planInstantCmsUpgrade(files, from, to) {
+    const comparison = (0, version_profiles_js_1.compareVersionProfiles)(from, to);
+    const audit = auditInstantCmsProject(files);
+    const code = Object.values(files).join('\n');
+    const referencedHooks = [
+        ...new Set([...code.matchAll(/['"]([a-z][a-z0-9_]+)['"]/g)].map(m => m[1])),
+    ]
+        .filter(name => name.includes('_'))
+        .filter(name => hooks_js_1.hooks.some(hook => hook.name === name));
+    const referencedMethods = [
+        ...new Set([...code.matchAll(/->([a-zA-Z_]\w*)\s*\(/g)].map(m => m[1])),
+    ];
+    const knownMethods = new Set(components_js_1.components.flatMap(component => component.methods.map(method => method.name)));
+    const unknownMethods = referencedMethods.filter(method => !knownMethods.has(method));
+    return {
+        from,
+        to,
+        comparison,
+        audit,
+        compatibility: {
+            referenced_hooks: referencedHooks,
+            unknown_method_candidates: unknownMethods,
+        },
+        checklist: [
+            'Повторно проверьте manifest.xml и minimum supported version.',
+            'Запустите audit_instantcms_project после изменений.',
+            'Проверьте install/uninstall на чистой целевой InstantCMS.',
+            'Перепроверьте hooks и методы с unknown_method_candidates вручную.',
+        ],
+    };
+}

package/dist/tools/requirement-tool.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeRequirement = analyzeRequirement;
+exports.suggestAddonStructure = suggestAddonStructure;
+const schemas_js_1 = require("../data/schemas.js");
+function analyzeRequirement(requirement) {
+    const lower = requirement.toLowerCase();
+    const features = [];
+    const requiredHooks = [];
+    const suggestedTables = [];
+    const recommendations = [];
+    const suggestedControllers = [];
+    let addonType = 'basic';
+    let complexity = 'low';
+    const nameSuggestion = generateName(requirement);
+    const titleSuggestion = generateTitle(requirement);
+    if (lower.includes('админ') ||
+        lower.includes('панель') ||
+        lower.includes('backend') ||
+        lower.includes('admin')) {
+        addonType = 'with_admin';
+        complexity = 'medium';
+        features.push('Админ-панель с CRUD');
+        suggestedControllers.push('backend');
+    }
+    if (lower.includes('событи') ||
+        lower.includes('хуки') ||
+        lower.includes('hook') ||
+        lower.includes('интеграц')) {
+        addonType = 'with_hooks';
+        if (complexity === 'low')
+            complexity = 'medium';
+        features.push('Интеграция через хуки');
+    }
+    if (lower.includes('rss') || lower.includes('лента') || lower.includes('feed')) {
+        requiredHooks.push('rss_feed_item');
+        features.push('RSS лента');
+    }
+    if (lower.includes('sitemap') || lower.includes('поисковик')) {
+        requiredHooks.push('sitemap_sources', 'sitemap_urls');
+        features.push('Интеграция с sitemap');
+    }
+    if (lower.includes('поиск') || lower.includes('search')) {
+        requiredHooks.push('search_sources', 'search_item');
+        features.push('Полнотекстовый поиск');
+        recommendations.push('Добавьте индексы для часто искомых полей');
+    }
+    if (lower.includes('тег') || lower.includes('tag')) {
+        requiredHooks.push('tagsdelete');
+        features.push('Система тегов');
+    }
+    if (lower.includes('рейтинг') || lower.includes('rating') || lower.includes('голос')) {
+        requiredHooks.push('rating_vote');
+        features.push('Рейтинг/голосование');
+    }
+    if (lower.includes('комментар') || lower.includes('comment')) {
+        requiredHooks.push('comments_after_add');
+        features.push('Комментарии');
+    }
+    if (lower.includes('уведомлен') || lower.includes('email') || lower.includes('notice')) {
+        features.push('Уведомления (email, in-site)');
+        recommendations.push("Используйте cmsCore::sendEmail() и cmsCore::getController('messages')->addNotice()");
+    }
+    if (lower.includes('категори') || lower.includes('иерархи')) {
+        suggestedTables.push({
+            name: 'categories',
+            fields: ['id', 'parent_id', 'title', 'slug', 'ordering'],
+        });
+        features.push('Иерархия категорий');
+    }
+    if (lower.includes('пользовател') || lower.includes('user') || lower.includes('профил')) {
+        suggestedControllers.push('users');
+        features.push('Профили пользователей');
+    }
+    if (lower.includes('регистрац') || lower.includes('auth')) {
+        requiredHooks.push('user_registered');
+        suggestedControllers.push('auth');
+        features.push('Авторизация/регистрация');
+    }
+    if (lower.includes('загруз') ||
+        lower.includes('upload') ||
+        lower.includes('файл') ||
+        lower.includes('image')) {
+        features.push('Загрузка файлов/изображений');
+        recommendations.push('Используйте fieldImage или fieldFile в формах');
+    }
+    if (lower.includes('кэш') || lower.includes('cache')) {
+        features.push('Кэширование данных');
+        recommendations.push('Используйте cmsCache::getInstance()->get()/set()');
+    }
+    if (lower.includes('cron') || lower.includes('планировщ') || lower.includes('schedul')) {
+        requiredHooks.push('cron_run');
+        features.push('Задачи по расписанию');
+        recommendations.push('Добавьте запись в cms_scheduler_tasks');
+    }
+    if (lower.includes('REST') ||
+        lower.includes('api') ||
+        lower.includes('ajax') ||
+        lower.includes('json')) {
+        features.push('API (AJAX/JSON endpoints)');
+        recommendations.push('Используйте $this->renderJSON() для AJAX ответов');
+        addonType = 'with_routes';
+    }
+    if (lower.includes('виджет') || lower.includes('widget')) {
+        addonType = 'with_widget';
+        features.push('Виджет для размещения на страницах');
+    }
+    if (lower.includes('каталог') ||
+        lower.includes('товар') ||
+        lower.includes('product') ||
+        lower.includes('catalog')) {
+        suggestedTables.push({
+            name: 'products',
+            fields: [
+                'id',
+                'title',
+                'description',
+                'price',
+                'category_id',
+                'user_id',
+                'date_pub',
+                'is_pub',
+            ],
+        });
+        suggestedTables.push({
+            name: 'categories',
+            fields: ['id', 'parent_id', 'title', 'slug', 'ordering'],
+        });
+        features.push('Каталог товаров');
+        complexity = 'high';
+    }
+    if (lower.includes('блог') || lower.includes('статья') || lower.includes('post')) {
+        suggestedTables.push({
+            name: 'posts',
+            fields: [
+                'id',
+                'title',
+                'slug',
+                'content',
+                'user_id',
+                'date_pub',
+                'is_pub',
+                'views',
+                'rating',
+            ],
+        });
+        features.push('Блог/статьи');
+        requiredHooks.push('content_after_add_approve', 'content_after_update_approve');
+    }
+    if (lower.includes('сообщен') || lower.includes('message') || lower.includes('chat')) {
+        suggestedTables.push({
+            name: 'messages',
+            fields: ['id', 'from_id', 'to_id', 'content', 'date_pub', 'is_read'],
+        });
+        suggestedControllers.push('messages');
+        features.push('Личные сообщения');
+        complexity = 'high';
+    }
+    const description = `Дополнение "${titleSuggestion}" ${features.length > 0 ? 'с функциями: ' + features.join(', ') : ''}`;
+    return {
+        addon_type: addonType,
+        suggested_name: nameSuggestion,
+        suggested_title: titleSuggestion,
+        description,
+        features,
+        required_hooks: [...new Set(requiredHooks)],
+        suggested_tables: suggestedTables,
+        suggested_controllers: [...new Set(suggestedControllers)],
+        estimated_complexity: complexity,
+        recommendations,
+    };
+}
+function generateName(requirement) {
+    const words = requirement
+        .toLowerCase()
+        .replace(/[^а-яёa-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 3)
+        .slice(0, 3);
+    let name = words.join('_').replace(/[aeiouyаеёиоуыэюя]/gi, '');
+    if (name.length < 4) {
+        name = words.join('').substring(0, 8);
+    }
+    return name || 'my_addon';
+}
+function generateTitle(requirement) {
+    const words = requirement
+        .toLowerCase()
+        .replace(/[^а-яёa-z\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2)
+        .slice(0, 4);
+    return words.map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ') || 'Мое дополнение';
+}
+function suggestAddonStructure(type) {
+    const structure = schemas_js_1.addonStructures[type];
+    if (!structure) {
+        return {
+            error: `Тип "${type}" не найден`,
+            available: Object.keys(schemas_js_1.addonStructures),
+        };
+    }
+    return {
+        type: structure.type,
+        description: structure.description,
+        files: structure.files.map(f => ({
+            path: f.path,
+            required: f.required,
+            description: f.description,
+        })),
+    };
+}