@maxisoft/instantcms-mcp 1.2.3

package/dist/tools/parser/traits-parser.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTraitsMap = generateTraitsMap;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function parseTraitFile(filePath, namespace) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const nameMatch = filePath.match(/([^\/]+)\.php$/);
+    if (!nameMatch)
+        return null;
+    const classMatch = content.match(/trait\s+(\w+)/);
+    if (!classMatch)
+        return null;
+    const traitName = classMatch[1];
+    let description;
+    const docMatch = content.match(/\*\*[\s\S]*?@/);
+    if (docMatch) {
+        const descMatch = docMatch[0].match(/@([\s\S]+?)@/);
+        if (descMatch) {
+            description = descMatch[1]
+                .trim()
+                .replace(/\n\s*\*/g, '\n')
+                .trim();
+        }
+    }
+    const methods = [];
+    const methodRegex = /(public|protected|private)\s+function\s+(\w+)\s*\(([^)]*)\)/g;
+    let methodMatch;
+    while ((methodMatch = methodRegex.exec(content)) !== null) {
+        const paramsStr = methodMatch[3].trim();
+        const params = paramsStr ? paramsStr.split(',').map(p => p.trim()) : [];
+        methods.push({
+            name: methodMatch[2],
+            visibility: methodMatch[1],
+            params,
+        });
+    }
+    return {
+        name: traitName,
+        namespace,
+        filePath: filePath.replace(process.cwd(), ''),
+        methods,
+        description,
+    };
+}
+function scanTraitsDir(dirPath, namespace, traits) {
+    if (!fs.existsSync(dirPath))
+        return;
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            const newNamespace = namespace ? `${namespace}\\${entry.name}` : entry.name;
+            scanTraitsDir(entryPath, newNamespace, traits);
+        }
+        else if (entry.name.endsWith('.php')) {
+            const trait = parseTraitFile(entryPath, namespace);
+            if (trait) {
+                traits.push(trait);
+            }
+        }
+    }
+}
+function generateTraitsMap(sourceDir, outputPath) {
+    const traitsDir = path.join(sourceDir, 'system', 'traits');
+    const traits = [];
+    scanTraitsDir(traitsDir, 'icms', traits);
+    const byNamespace = {};
+    for (const trait of traits) {
+        if (!byNamespace[trait.namespace]) {
+            byNamespace[trait.namespace] = [];
+        }
+        byNamespace[trait.namespace].push(trait);
+    }
+    const data = {
+        traits,
+        byNamespace,
+        methodCount: traits.reduce((sum, t) => sum + t.methods.length, 0),
+        generatedAt: process.env.KNOWLEDGE_GENERATED_AT || new Date().toISOString(),
+    };
+    const typescriptContent = `// AUTO-GENERATED from source/system/traits
+// Do not edit manually - run 'npm run parse:traits' to regenerate
+
+export interface TraitMethod {
+  name: string;
+  visibility: 'public' | 'protected' | 'private';
+  params: string[];
+  description?: string;
+}
+
+export interface TraitInfo {
+  name: string;
+  namespace: string;
+  filePath: string;
+  methods: TraitMethod[];
+  description?: string;
+}
+
+export interface TraitsMap {
+  traits: TraitInfo[];
+  byNamespace: Record<string, TraitInfo[]>;
+  methodCount: number;
+  generatedAt: string;
+}
+
+export const traitsMap: TraitsMap = ${JSON.stringify(data, null, 2)};
+
+export function getTrait(name: string): TraitInfo | undefined {
+  return traitsMap.traits.find(t => t.name === name);
+}
+
+export function getTraitMethods(name: string): TraitMethod[] {
+  const trait = getTrait(name);
+  return trait?.methods || [];
+}
+
+export function getTraitsByNamespace(namespace: string): TraitInfo[] {
+  return traitsMap.byNamespace[namespace] || [];
+}
+`;
+    fs.writeFileSync(outputPath, typescriptContent);
+    console.log(`Generated ${data.traits.length} traits with ${data.methodCount} methods to ${outputPath}`);
+}
+if (require.main === module) {
+    const sourcePath = path.resolve(process.env.INSTANTCMS_SOURCE || 'source');
+    const outputPath = path.resolve('src/data/traits-map.ts');
+    generateTraitsMap(sourcePath, outputPath);
+}

package/dist/tools/parser/widgets-parser.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWidgetsMap = generateWidgetsMap;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function scanWidgetsDir(dirPath, widgets) {
+    if (!fs.existsSync(dirPath))
+        return;
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith('.'))
+            continue;
+        const widgetPath = path.join(dirPath, entry.name);
+        const widgetFile = path.join(widgetPath, 'widget.php');
+        const optionsFormFile = path.join(widgetPath, 'options.form.php');
+        if (fs.existsSync(widgetFile)) {
+            const content = fs.readFileSync(widgetFile, 'utf-8');
+            const classMatch = content.match(/class\s+(widget\w+)\s+extends\s+(\w+)/);
+            if (classMatch) {
+                const className = classMatch[1];
+                let controller;
+                const controllerMatch = className.match(/^widget([A-Z]\w+)$/);
+                if (controllerMatch) {
+                    controller = controllerMatch[1].toLowerCase();
+                }
+                let description;
+                const docMatch = content.match(/\*\s*([^\n]+)/);
+                if (docMatch) {
+                    description = docMatch[1].trim();
+                }
+                widgets.push({
+                    name: entry.name,
+                    className,
+                    controller,
+                    filePath: widgetFile.replace(process.cwd(), ''),
+                    hasOptionsForm: fs.existsSync(optionsFormFile),
+                    optionsFormPath: fs.existsSync(optionsFormFile)
+                        ? optionsFormFile.replace(process.cwd(), '')
+                        : undefined,
+                    description,
+                });
+            }
+        }
+    }
+}
+function generateWidgetsMap(sourceDir, outputPath) {
+    const widgetsDir = path.join(sourceDir, 'system', 'widgets');
+    const widgets = [];
+    scanWidgetsDir(widgetsDir, widgets);
+    const byName = {};
+    const byController = {};
+    for (const widget of widgets) {
+        byName[widget.name] = widget;
+        const ctrl = widget.controller || '_system';
+        if (!byController[ctrl]) {
+            byController[ctrl] = [];
+        }
+        byController[ctrl].push(widget);
+    }
+    const data = {
+        widgets,
+        byName,
+        byController,
+        widgetCount: widgets.length,
+        generatedAt: process.env.KNOWLEDGE_GENERATED_AT || new Date().toISOString(),
+    };
+    const typescriptContent = `// AUTO-GENERATED from source/system/widgets
+// Do not edit manually - run 'npm run parse:widgets' to regenerate
+
+export interface WidgetOption {
+  name: string;
+  type: string;
+  description?: string;
+}
+
+export interface WidgetInfo {
+  name: string;
+  className: string;
+  controller?: string;
+  filePath: string;
+  hasOptionsForm: boolean;
+  optionsFormPath?: string;
+  description?: string;
+}
+
+export interface WidgetsMap {
+  widgets: WidgetInfo[];
+  byName: Record<string, WidgetInfo>;
+  byController: Record<string, WidgetInfo[]>;
+  widgetCount: number;
+  generatedAt: string;
+}
+
+export const widgetsMap: WidgetsMap = ${JSON.stringify(data, null, 2)};
+
+export function getWidget(name: string): WidgetInfo | undefined {
+  return widgetsMap.byName[name];
+}
+
+export function getWidgetsByController(controller: string): WidgetInfo[] {
+  return widgetsMap.byController[controller] || [];
+}
+
+export function getSystemWidgets(): WidgetInfo[] {
+  return widgetsMap.byController['_system'] || [];
+}
+`;
+    fs.writeFileSync(outputPath, typescriptContent);
+    console.log(`Generated ${data.widgetCount} widgets to ${outputPath}`);
+}
+if (require.main === module) {
+    const sourcePath = path.resolve(process.env.INSTANTCMS_SOURCE || 'source');
+    const outputPath = path.resolve('src/data/widgets-map.ts');
+    generateWidgetsMap(sourcePath, outputPath);
+}

package/dist/tools/permission-tool.js

@@ -0,0 +1,348 @@
+"use strict";
+/**
+ * @fileoverview Permission system scaffolding tool for InstantCMS
+ * Generates permission checker, hooks, and admin backend
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permissionSchema = exports.PermissionTypeEnum = void 0;
+exports.scaffoldPermission = scaffoldPermission;
+const zod_1 = require("zod");
+const scaffold_1 = require("../types/scaffold");
+/**
+ * Available permission types in InstantCMS
+ */
+exports.PermissionTypeEnum = zod_1.z.enum([
+    'view',
+    'add',
+    'edit',
+    'delete',
+    'publish',
+    'moderate',
+    'admin',
+]);
+/**
+ * Built-in permission rules for InstantCMS content types
+ */
+const PERMISSION_RULES = [
+    { type: 'view', description: 'Просмотр контента', defaultRoles: ['all'] },
+    { type: 'add', description: 'Добавление контента', defaultRoles: ['auth'] },
+    { type: 'edit', description: 'Редактирование своего', defaultRoles: ['auth'] },
+    { type: 'delete', description: 'Удаление своего', defaultRoles: ['auth'] },
+    { type: 'publish', description: 'Публикация', defaultRoles: ['moderator', 'admin'] },
+    { type: 'moderate', description: 'Модерация', defaultRoles: ['moderator', 'admin'] },
+    { type: 'admin', description: 'Администрирование', defaultRoles: ['admin'] },
+];
+/**
+ * Zod schema for permission tool input validation
+ */
+exports.permissionSchema = zod_1.z.object({
+    /** System name (lowercase, snake_case) */
+    name: zod_1.z
+        .string()
+        .min(1)
+        .max(50)
+        .regex(/^[a-z][a-z0-9_]*$/, 'Только lowercase буквы, цифры и подчёркивание'),
+    /** Display title */
+    title: zod_1.z.string().min(1).max(100),
+    /** Optional description */
+    description: zod_1.z.string().optional(),
+    /** Controller name */
+    controller: zod_1.z.string().optional(),
+    /** List of permissions to generate */
+    permissions: zod_1.z
+        .array(zod_1.z.enum(['view', 'add', 'edit', 'delete', 'publish', 'moderate', 'admin']))
+        .optional(),
+    /** Permission category */
+    category: zod_1.z.string().optional(),
+    /** Additional options */
+    options: zod_1.z
+        .object({
+        /** Enable category-based permissions */
+        withCategories: zod_1.z.boolean().optional().default(false),
+        /** Check item ownership for edit/delete */
+        withOwnership: zod_1.z.boolean().optional().default(true),
+        /** Generate role-based permissions */
+        withRoles: zod_1.z.boolean().optional().default(true),
+    })
+        .optional(),
+});
+/**
+ * Generates the manifest.json file
+ */
+function generateManifest(name, title, description, controller, permissions, category, options) {
+    return `<?php
+// InstantCMS 2. manifest.json
+return [
+    'type' => 'content_type',
+    'name' => '${name}',
+    'title' => '${title}',
+    'description' => '${description}',
+    'controller' => '${controller}',
+    'permissions' => ['${permissions.join("', '")}'],
+    'category' => '${category}',
+    'version' => '1.0.0',
+    'dependencies' => [],
+    'options' => [
+        'categories' => ${options?.withCategories ?? false},
+        'ownership' => ${options?.withOwnership ?? true},
+        'roles' => ${options?.withRoles ?? true},
+    ],
+];`;
+}
+/**
+ * Generates the permission configuration file
+ */
+function generatePermissionConfig(name, title, description, controller, permissions, category) {
+    const permConfigs = PERMISSION_RULES.filter(r => permissions.includes(r.type))
+        .map(r => `        '${r.type}' => [
+            'title' => '${r.description}',
+            'default' => ['${r.defaultRoles.join("', '")}'],
+        ]`)
+        .join(',\n');
+    return `<?php
+// InstantCMS 2. system/config/permissions/${name}.php
+
+return [
+    'name' => '${name}',
+    'title' => '${title}',
+    'description' => '${description}',
+    'controller' => '${controller}',
+    'category' => '${category}',
+    'rules' => [
+${permConfigs}
+    ],
+];`;
+}
+/**
+ * Generates the permissions.php checker class
+ */
+function generatePermissionChecker(name, nameCapital, permissions, options) {
+    const permStrings = permissions.map(p => `'${p}'`).join(', ');
+    return `<?php
+// InstantCMS 2. ${name}/permissions.php
+
+class ${nameCapital}Permissions {
+    private static $instance = null;
+    private $config = [];
+
+    private function __construct() {
+        $config_path = cmsConfig::get('root_path') . '/system/config/permissions/${name}.php';
+        if (file_exists($config_path)) {
+            $this->config = include $config_path;
+        }
+    }
+
+    public static function getInstance() {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+        return self::$instance;
+    }
+
+    public function can($permission, $user_id = null, $item = null) {
+        $user_id = $user_id ?: cmsUser::getInstance()->id;
+
+        if (!$user_id) {
+            return in_array($permission, ['view']);
+        }
+
+        $user = cmsModel::getInstance('users')->getUser($user_id);
+        if (!$user) {
+            return false;
+        }
+
+        if (${options?.withOwnership ?? true} && $item) {
+            if ($item['user_id'] == $user_id && in_array($permission, ['edit', 'delete'])) {
+                return true;
+            }
+        }
+
+        $rules = $this->config['rules'][$permission]['default'] ?? [];
+
+        if ($user['is_admin'] || in_array('admin', $rules)) {
+            return true;
+        }
+
+        return in_array($this->getRoleById($user['role_id']), $rules);
+    }
+
+    private function getRoleById($role_id) {
+        $roles = [
+            1 => 'admin',
+            2 => 'moderator',
+            3 => 'auth',
+            4 => 'all',
+        ];
+        return $roles[$role_id] ?? 'all';
+    }
+
+    public function getAvailablePermissions() {
+        return [${permStrings}];
+    }
+}`;
+}
+/**
+ * Generates hook handlers for permission events
+ */
+function generateHookHandlers(name, nameCapital) {
+    return `<?php
+// InstantCMS 2. hooks/${name}/permissions.hooks.php
+
+class on${nameCapital}PermissionsHook {
+    public function onUserAfterLogin($user) {
+        $permissions = ${nameCapital}Permissions::getInstance();
+    }
+
+    public function onContentBeforeSave($item) {
+        $permissions = ${nameCapital}Permissions::getInstance();
+
+        if (!$permissions->can('edit', null, $item)) {
+            cmsUser::addSessionMessage('У вас нет прав на редактирование', 'error');
+            return false;
+        }
+
+        return $item;
+    }
+
+    public function onContentBeforeDelete($item) {
+        $permissions = ${nameCapital}Permissions::getInstance();
+
+        if (!$permissions->can('delete', null, $item)) {
+            cmsUser::addSessionMessage('У вас нет прав на удаление', 'error');
+            return false;
+        }
+
+        return $item;
+    }
+}`;
+}
+/**
+ * Generates admin backend for permissions management
+ */
+function generateAdminBackend(name, nameCapital, permissions) {
+    const permStrings = permissions.map(p => `'${p}'`).join(', ');
+    return `<?php
+// InstantCMS 2. ${name}/backend/permissions.php
+
+class backend${nameCapital}Permissions extends cmsBackend {
+
+    protected $useOptions = false;
+
+    public function __construct($request) {
+        parent::__construct($request);
+        $this->controlName = '${nameCapital}Permissions';
+    }
+
+    public function actionIndex() {
+        $this->renderTemplate('permissions', [
+            'permissions' => ${nameCapital}Permissions::getInstance()->getAvailablePermissions(),
+            'roles' => $this->model->getRoles(),
+        ]);
+    }
+
+    public function actionSave() {
+        $data = $this->request->getAll();
+
+        $config_path = cmsConfig::get('root_path') . '/system/config/permissions/${name}.php';
+
+        $config = [
+            'name' => '${name}',
+            'title' => '${nameCapital}',
+            'rules' => [],
+        ];
+
+        foreach ([${permStrings}] as $perm) {
+            $config['rules'][$perm] = [
+                'title' => $data['titles'][$perm] ?? '',
+                'default' => $data['defaults'][$perm] ?? [],
+            ];
+        }
+
+        file_put_contents($config_path, '<?php\\nreturn ' . var_export($config, true) . ';');
+
+        cmsUser::addSessionMessage('Права сохранены', 'success');
+        $this->redirectToAction('index');
+    }
+
+    public function actionCheck() {
+        $permission = $this->request->get('permission', '');
+        $user_id = $this->request->get('user_id', 0);
+
+        $permissions = ${nameCapital}Permissions::getInstance();
+        $result = $permissions->can($permission, $user_id);
+
+        $this->halt(200, json_encode(['allowed' => $result]));
+    }
+}`;
+}
+/**
+ * Generates roles configuration file
+ */
+function generateRoles(name, permissions) {
+    return `<?php
+// InstantCMS 2. ${name}/roles.php
+
+return [
+    'admin' => [
+        'title' => 'Администратор',
+        'permissions' => ['${permissions.join("', '")}'],
+    ],
+    'moderator' => [
+        'title' => 'Модератор',
+        'permissions' => ['${permissions.filter((p) => p !== 'admin').join("', '")}'],
+    ],
+    'auth' => [
+        'title' => 'Авторизованный',
+        'permissions' => ['view', 'add'],
+    ],
+    'all' => [
+        'title' => 'Гость',
+        'permissions' => ['view'],
+    ],
+];`;
+}
+/**
+ * Generates a complete permission system for an InstantCMS addon
+ *
+ * @param input - Configuration for the permission system
+ * @returns Object containing generated files and metadata
+ *
+ * @example
+ * ```typescript
+ * const result = scaffoldPermission({
+ *   name: 'blog_post',
+ *   title: 'Записи блога',
+ *   permissions: ['view', 'add', 'edit', 'delete'],
+ *   options: { withOwnership: true, withRoles: true }
+ * });
+ * ```
+ */
+function scaffoldPermission(input) {
+    const { lowercase, UpperCamelCase } = (0, scaffold_1.normalizeAddonName)(input.name);
+    const title = input.title;
+    const description = input.description || '';
+    const controller = input.controller || lowercase;
+    const permissions = input.permissions || ['view', 'add', 'edit', 'delete'];
+    const category = input.category || 'content';
+    const options = {
+        withCategories: input.options?.withCategories ?? false,
+        withOwnership: input.options?.withOwnership ?? true,
+        withRoles: input.options?.withRoles ?? true,
+    };
+    const files = {};
+    files[`${lowercase}/manifest.json`] = generateManifest(lowercase, title, description, controller, permissions, category, options);
+    files[`system/config/permissions/${lowercase}.php`] = generatePermissionConfig(lowercase, title, description, controller, permissions, category);
+    files[`${lowercase}/permissions.php`] = generatePermissionChecker(lowercase, UpperCamelCase, permissions, options);
+    files[`system/hooks/${lowercase}/permissions.hooks.php`] = generateHookHandlers(lowercase, UpperCamelCase);
+    files[`${lowercase}/backend/permissions.php`] = generateAdminBackend(lowercase, UpperCamelCase, permissions);
+    if (options.withRoles) {
+        files[`${lowercase}/roles.php`] = generateRoles(lowercase, permissions);
+    }
+    return {
+        addon_name: lowercase,
+        title,
+        permissions_count: permissions.length,
+        options,
+        files,
+    };
+}