@maxisoft/instantcms-mcp 1.2.3

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

@@ -0,0 +1,313 @@
+"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.generateControllersMap = generateControllersMap;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function parsePhpFile(content) {
+    const classMatch = content.match(/class\s+(\w+)\s+extends\s+(\w+)/);
+    if (!classMatch)
+        return null;
+    const className = classMatch[1];
+    const extendsClass = classMatch[2];
+    const traitMatches = content.matchAll(/use\s+([a-zA-Z0-9_\\]+)\s*;/g);
+    const traits = [];
+    for (const match of traitMatches) {
+        const fullTrait = match[1];
+        if (fullTrait.startsWith('icms') || fullTrait.startsWith('cms')) {
+            const trait = fullTrait.replace(/^(icms|cms)[\\]?/, '');
+            if (trait && trait.includes('\\') && !traits.includes(trait)) {
+                traits.push(trait);
+            }
+        }
+    }
+    const actions = [];
+    const actionRegex = /(public|private|protected)\s+function\s+(action\w+)\s*\(([^)]*)\)/g;
+    let actionMatch;
+    while ((actionMatch = actionRegex.exec(content)) !== null) {
+        const paramsStr = actionMatch[3].trim();
+        const params = paramsStr ? paramsStr.split(',').map(p => p.trim()) : [];
+        actions.push({
+            name: actionMatch[2],
+            visibility: actionMatch[1],
+            params,
+        });
+    }
+    return { className, extends: extendsClass, traits, actions };
+}
+function normalizeControllerName(name, type) {
+    if (type === 'backend') {
+        if (name.startsWith('backend')) {
+            return name.replace(/^backend/i, '').toLowerCase();
+        }
+    }
+    return name.toLowerCase();
+}
+function detectControllerType(className, extendsClass, filePath) {
+    if (className.toLowerCase().startsWith('backend'))
+        return 'backend';
+    if (extendsClass.toLowerCase().includes('backend'))
+        return 'backend';
+    if (filePath.includes('/backend/'))
+        return 'backend';
+    return 'frontend';
+}
+function scanControllerDir(dirPath, controllers) {
+    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 controllerPath = path.join(dirPath, entry.name);
+        const frontendPath = path.join(controllerPath, 'frontend.php');
+        const backendPath = path.join(controllerPath, 'backend.php');
+        const actionsDir = path.join(controllerPath, 'actions');
+        const modelPath = path.join(controllerPath, 'model.php');
+        const backendModelPath = path.join(controllerPath, 'backend', 'model.php');
+        const controllerInfo = {
+            name: entry.name,
+            className: '',
+            type: 'frontend',
+            extends: '',
+            filePath: '',
+            actions: [],
+            hasBackendFolder: fs.existsSync(path.join(controllerPath, 'backend')),
+            hasModel: fs.existsSync(modelPath),
+            modelFile: fs.existsSync(modelPath) ? 'model.php' : undefined,
+        };
+        if (fs.existsSync(backendModelPath)) {
+            controllerInfo.hasBackendFolder = true;
+            controllerInfo.modelFile = 'backend/model.php';
+        }
+        if (fs.existsSync(frontendPath)) {
+            const parsed = parsePhpFile(fs.readFileSync(frontendPath, 'utf-8'));
+            if (parsed) {
+                controllerInfo.className = parsed.className;
+                controllerInfo.extends = parsed.extends;
+                controllerInfo.filePath = frontendPath.replace(process.cwd(), '');
+                controllerInfo.type = detectControllerType(parsed.className, parsed.extends, frontendPath);
+                controllerInfo.name = normalizeControllerName(entry.name, controllerInfo.type);
+                for (const action of parsed.actions) {
+                    controllerInfo.actions.push({
+                        name: action.name,
+                        className: parsed.className,
+                        filePath: frontendPath.replace(process.cwd(), ''),
+                        visibility: action.visibility,
+                        hasParams: action.params.length > 0,
+                        params: action.params,
+                        traits: parsed.traits,
+                    });
+                }
+                if (fs.existsSync(backendPath)) {
+                    controllerInfo.hasBackendFolder = true;
+                }
+                controllers.push(controllerInfo);
+            }
+        }
+        if (fs.existsSync(backendPath)) {
+            const parsed = parsePhpFile(fs.readFileSync(backendPath, 'utf-8'));
+            if (parsed) {
+                const backendInfo = {
+                    name: normalizeControllerName(entry.name, 'backend'),
+                    className: parsed.className,
+                    type: 'backend',
+                    extends: parsed.extends,
+                    filePath: backendPath.replace(process.cwd(), ''),
+                    actions: [],
+                    hasBackendFolder: true,
+                    hasModel: fs.existsSync(modelPath) || fs.existsSync(backendModelPath),
+                    modelFile: fs.existsSync(backendModelPath)
+                        ? 'backend/model.php'
+                        : fs.existsSync(modelPath)
+                            ? 'model.php'
+                            : undefined,
+                };
+                for (const action of parsed.actions) {
+                    backendInfo.actions.push({
+                        name: action.name,
+                        className: parsed.className,
+                        filePath: backendPath.replace(process.cwd(), ''),
+                        visibility: action.visibility,
+                        hasParams: action.params.length > 0,
+                        params: action.params,
+                        traits: parsed.traits,
+                    });
+                }
+                controllers.push(backendInfo);
+            }
+        }
+        if (fs.existsSync(actionsDir) && fs.statSync(actionsDir).isDirectory()) {
+            const actionFiles = fs.readdirSync(actionsDir).filter(f => f.endsWith('.php'));
+            for (const actionFile of actionFiles) {
+                const actionPath = path.join(actionsDir, actionFile);
+                const content = fs.readFileSync(actionPath, 'utf-8');
+                const parsed = parsePhpFile(content);
+                if (parsed && parsed.className) {
+                    let controllerName = entry.name;
+                    let controllerType = 'frontend';
+                    let actionNameFromClass = '';
+                    const knownControllers = [
+                        'Content',
+                        'Users',
+                        'Messages',
+                        'Activity',
+                        'Admin',
+                        'Auth',
+                        'Comments',
+                    ];
+                    let matchedCtrl = '';
+                    for (const ctrl of knownControllers) {
+                        if (parsed.className.startsWith('action' + ctrl)) {
+                            matchedCtrl = ctrl;
+                            break;
+                        }
+                    }
+                    if (matchedCtrl) {
+                        controllerName = matchedCtrl.toLowerCase();
+                        actionNameFromClass = parsed.className.replace('action' + matchedCtrl, 'action');
+                        if (parsed.className.toLowerCase().startsWith('actionadmin') ||
+                            parsed.className.toLowerCase().startsWith('backend')) {
+                            controllerType = 'backend';
+                        }
+                    }
+                    const existingController = controllers.find(c => c.name === controllerName && c.type === controllerType);
+                    const fileActionName = actionFile
+                        .replace('.php', '')
+                        .replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+                    if (existingController) {
+                        existingController.actions.push({
+                            name: actionNameFromClass ||
+                                'action' + fileActionName.charAt(0).toUpperCase() + fileActionName.slice(1),
+                            className: parsed.className,
+                            filePath: actionPath.replace(process.cwd(), ''),
+                            visibility: (parsed.actions[0]?.visibility ||
+                                'public'),
+                            hasParams: (parsed.actions[0]?.params?.length || 0) > 0,
+                            params: parsed.actions[0]?.params || [],
+                            traits: parsed.traits,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+function generateControllersMap(sourceDir, outputPath) {
+    const controllersDir = path.join(sourceDir, 'system', 'controllers');
+    const controllers = [];
+    scanControllerDir(controllersDir, controllers);
+    controllers.sort((a, b) => a.name.localeCompare(b.name));
+    const byName = {};
+    for (const ctrl of controllers) {
+        const key = `${ctrl.name}_${ctrl.type}`;
+        if (!byName[key]) {
+            byName[key] = ctrl;
+        }
+    }
+    const data = {
+        controllers,
+        byName,
+        controllerCount: controllers.length,
+        generatedAt: process.env.KNOWLEDGE_GENERATED_AT || new Date().toISOString(),
+    };
+    const typescriptContent = `// AUTO-GENERATED from source/system/controllers
+// Do not edit manually - run 'npm run parse:controllers' to regenerate
+
+export interface ControllerAction {
+  name: string;
+  className: string;
+  filePath: string;
+  visibility: 'public' | 'private' | 'protected';
+  hasParams: boolean;
+  params: string[];
+  traits: string[];
+  description?: string;
+}
+
+export interface ControllerInfo {
+  name: string;
+  className: string;
+  type: 'frontend' | 'backend';
+  extends: string;
+  filePath: string;
+  actions: ControllerAction[];
+  hasBackendFolder: boolean;
+  hasModel: boolean;
+  modelFile?: string;
+}
+
+export interface ControllersMap {
+  controllers: ControllerInfo[];
+  byName: Record<string, ControllerInfo>;
+  controllerCount: number;
+  generatedAt: string;
+}
+
+export const controllersMap: ControllersMap = ${JSON.stringify(data, null, 2)};
+
+export function getController(name: string, type?: 'frontend' | 'backend'): ControllerInfo | undefined {
+  if (type) {
+    return controllersMap.controllers.find(c => c.name === name && c.type === type);
+  }
+  return controllersMap.controllers.find(c => c.name === name);
+}
+
+export function getControllerActions(name: string, type?: 'frontend' | 'backend'): ControllerAction[] {
+  const ctrl = getController(name, type);
+  return ctrl?.actions || [];
+}
+
+export function getControllersWithBackend(): ControllerInfo[] {
+  return controllersMap.controllers.filter(c => c.type === 'frontend' && c.hasBackendFolder);
+}
+
+export function getBackendControllers(): ControllerInfo[] {
+  return controllersMap.controllers.filter(c => c.type === 'backend');
+}
+`;
+    fs.writeFileSync(outputPath, typescriptContent);
+    console.log(`Generated ${data.controllerCount} controller entries to ${outputPath}`);
+    const uniqueControllers = new Set(controllers.map(c => `${c.name}_${c.type}`));
+    console.log(`Unique controllers: ${uniqueControllers.size}`);
+    console.log(`Total actions: ${controllers.reduce((sum, c) => sum + c.actions.length, 0)}`);
+}
+if (require.main === module) {
+    const sourcePath = path.resolve(process.env.INSTANTCMS_SOURCE || 'source');
+    const outputPath = path.resolve('src/data/controllers-map.ts');
+    generateControllersMap(sourcePath, outputPath);
+}

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

@@ -0,0 +1,294 @@
+"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.parseCoreFile = parseCoreFile;
+exports.parseAllCoreFiles = parseAllCoreFiles;
+exports.generateCoreAPIData = generateCoreAPIData;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob = __importStar(require("glob"));
+function getVisibility(modifiers) {
+    if (modifiers.includes('private'))
+        return 'private';
+    if (modifiers.includes('protected'))
+        return 'protected';
+    if (modifiers.includes('static'))
+        return 'static';
+    return 'public';
+}
+function extractReturnType(docComment) {
+    const returnMatch = docComment.match(/@return\s+([^\s*]+)/);
+    if (returnMatch)
+        return returnMatch[1];
+    return 'void';
+}
+function cleanDescription(desc) {
+    let result = desc
+        .replace(/^\/\*\*[\s\*]*/gm, '')
+        .replace(/\*\/$/gm, '')
+        .replace(/^\s*\*\s*/gm, ' ')
+        .replace(/^\s*$/gm, '')
+        .trim();
+    result = result.replace(/\s+/g, ' ').trim();
+    if (result.includes('class ') ||
+        result.includes('function ') ||
+        result.includes('protected $') ||
+        result.includes('public $')) {
+        return '';
+    }
+    if (result.length > 10 && (result.includes('*/') || result.includes('/**'))) {
+        return '';
+    }
+    return result.slice(0, 200);
+}
+function isDeprecated(docComment) {
+    return docComment.includes('@deprecated');
+}
+function extractMethods(content) {
+    const methods = [];
+    const methodPattern = /(?:\/\*\*([\s\S]*?)\*\/\s*)?((?:(?:public|private|protected|static|final|abstract)\s+)*)function\s+&?\s*(\w+)\s*\(([^)]*)\)\s*(?::\s*([^\s{]+))?/g;
+    for (const match of content.matchAll(methodPattern)) {
+        const docComment = match[1] ? `/**${match[1]}*/` : '';
+        const modifiers = match[2].trim().split(/\s+/).filter(Boolean);
+        const funcName = match[3];
+        const paramsStr = match[4];
+        const returnType = match[5] || (docComment ? extractReturnType(docComment) : 'mixed');
+        const params = paramsStr
+            .split(',')
+            .map(part => part.trim())
+            .filter(Boolean)
+            .flatMap(part => {
+            const parameter = part.match(/^(?:(.*?)\s+)?(?:&\s*)?(\.\.\.)?\$([a-zA-Z_]\w*)\s*(?:=\s*(.+))?$/);
+            if (!parameter)
+                return [];
+            return [
+                {
+                    name: parameter[3],
+                    type: `${parameter[2] || ''}${parameter[1] || 'mixed'}`,
+                    description: '',
+                    required: parameter[4] === undefined,
+                    default: parameter[4]?.trim(),
+                },
+            ];
+        });
+        methods.push({
+            name: funcName,
+            visibility: getVisibility(modifiers),
+            signature: `function ${funcName}(${paramsStr}): ${returnType}`,
+            description: cleanDescription(docComment),
+            returnType,
+            params,
+            deprecated: isDeprecated(docComment),
+        });
+    }
+    return methods;
+}
+function extractProperties(content) {
+    const properties = [];
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim().startsWith('/**')) {
+            const docLines = [line];
+            i++;
+            while (i < lines.length && !lines[i].trim().startsWith('*/')) {
+                docLines.push(lines[i]);
+                i++;
+            }
+            if (i < lines.length) {
+                docLines.push(lines[i]);
+                i++;
+            }
+            const docComment = docLines.join('\n');
+            while (i < lines.length && !lines[i].match(/\$(public|private|protected)\s+\$/)) {
+                if (lines[i].match(/\$(public|private|protected)\s+\w/)) {
+                    const propMatch = lines[i].match(/\$(public|private|protected)\s+\$(\w+)/);
+                    if (propMatch) {
+                        properties.push({
+                            name: propMatch[2],
+                            visibility: getVisibility([propMatch[1]]),
+                            type: 'mixed',
+                            description: cleanDescription(docComment),
+                        });
+                    }
+                    i++;
+                    break;
+                }
+                i++;
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return properties;
+}
+function extractConstants(content) {
+    const constants = [];
+    const constRegex = /^\s*const\s+(\w+)\s*=\s*([^;]+);/gm;
+    let match;
+    while ((match = constRegex.exec(content)) !== null) {
+        constants.push({
+            name: match[1],
+            value: match[2].trim().slice(0, 100),
+            description: '',
+        });
+    }
+    return constants;
+}
+function parseCoreFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const classMatch = content.match(/class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+    if (!classMatch)
+        return null;
+    const className = classMatch[1];
+    const extendsClass = classMatch[2];
+    const fileName = path.basename(filePath, '.php');
+    const classDocMatch = content.match(/\/\*\*[\s\S]*?\*\//);
+    const description = classDocMatch ? cleanDescription(classDocMatch[0]) : '';
+    const methods = extractMethods(content);
+    const properties = extractProperties(content);
+    const constants = extractConstants(content);
+    return {
+        name: className,
+        extends: extendsClass,
+        description,
+        file: fileName,
+        methods,
+        properties,
+        constants,
+    };
+}
+function parseAllCoreFiles(sourceDir) {
+    const pattern = path.join(sourceDir, 'system', 'core', '*.php');
+    const files = glob.sync(pattern);
+    const classes = [];
+    for (const file of files) {
+        const parsed = parseCoreFile(file);
+        if (parsed) {
+            classes.push(parsed);
+        }
+    }
+    return classes.sort((a, b) => a.name.localeCompare(b.name));
+}
+function generateCoreAPIData(sourceDir) {
+    const classes = parseAllCoreFiles(sourceDir);
+    const lines = [
+        `// Auto-generated from system/core/*.php`,
+        `// Generated at: ${process.env.KNOWLEDGE_GENERATED_AT || new Date().toISOString()}`,
+        ``,
+        `export interface CoreClass {`,
+        `  name: string;`,
+        `  extends?: string;`,
+        `  description: string;`,
+        `  file: string;`,
+        `  methods: number;`,
+        `  properties: number;`,
+        `  constants: number;`,
+        `}`,
+        ``,
+        `export const coreClasses: CoreClass[] = [`,
+    ];
+    for (const cls of classes) {
+        lines.push(`  {`);
+        lines.push(`    name: ${JSON.stringify(cls.name)},`);
+        if (cls.extends)
+            lines.push(`    extends: ${JSON.stringify(cls.extends)},`);
+        lines.push(`    description: ${JSON.stringify(cls.description)},`);
+        lines.push(`    file: ${JSON.stringify(`${cls.file}.php`)},`);
+        lines.push(`    methods: ${cls.methods.length},`);
+        lines.push(`    properties: ${cls.properties.length},`);
+        lines.push(`    constants: ${cls.constants.length},`);
+        lines.push(`  },`);
+    }
+    lines.push(`];`);
+    lines.push(``);
+    lines.push(`export const coreAPIMap = {`);
+    for (const cls of classes) {
+        lines.push(`  ${cls.name}: {`);
+        lines.push(`    name: ${JSON.stringify(cls.name)},`);
+        lines.push(`    extends: ${cls.extends ? JSON.stringify(cls.extends) : 'undefined'},`);
+        lines.push(`    file: ${JSON.stringify(`${cls.file}.php`)},`);
+        lines.push(`    description: ${JSON.stringify(cls.description)},`);
+        lines.push(`    methods: [`);
+        for (const method of cls.methods) {
+            lines.push(`      {`);
+            lines.push(`        name: ${JSON.stringify(method.name)},`);
+            lines.push(`        visibility: ${JSON.stringify(method.visibility)},`);
+            lines.push(`        signature: ${JSON.stringify(method.signature)},`);
+            lines.push(`        returnType: ${JSON.stringify(method.returnType)},`);
+            lines.push(`        params: ${JSON.stringify(method.params)},`);
+            lines.push(`        description: ${JSON.stringify(method.description)},`);
+            if (method.deprecated)
+                lines.push(`        deprecated: true,`);
+            lines.push(`      },`);
+        }
+        lines.push(`    ],`);
+        lines.push(`    properties: [`);
+        for (const prop of cls.properties.slice(0, 20)) {
+            lines.push(`      ${JSON.stringify(prop)},`);
+        }
+        if (cls.properties.length > 20) {
+            lines.push(`      // ... ${cls.properties.length - 20} more properties`);
+        }
+        lines.push(`    ],`);
+        lines.push(`    constants: [`);
+        for (const c of cls.constants) {
+            lines.push(`      ${JSON.stringify(c)},`);
+        }
+        lines.push(`    ],`);
+        lines.push(`  },`);
+    }
+    lines.push(`};`);
+    return lines.join('\n');
+}
+if (require.main === module) {
+    const sourceDir = path.resolve(process.env.INSTANTCMS_SOURCE || path.resolve(__dirname, '../../../source'));
+    const outputFile = path.resolve(__dirname, '../../../src/data/core-api.ts');
+    console.log(`Parsing system/core/ files from: ${sourceDir}`);
+    const classes = parseAllCoreFiles(sourceDir);
+    console.log(`\nFound ${classes.length} core classes:\n`);
+    for (const cls of classes) {
+        const publicMethods = cls.methods.filter(m => m.visibility === 'public');
+        console.log(`  ${cls.name}${cls.extends ? ` extends ${cls.extends}` : ''} (${cls.file}.php)`);
+        console.log(`    Methods: ${cls.methods.length} (${publicMethods.length} public)`);
+        console.log(`    Properties: ${cls.properties.length}`);
+        console.log(`    Constants: ${cls.constants.length}`);
+    }
+    const output = generateCoreAPIData(sourceDir);
+    fs.writeFileSync(outputFile, output);
+    console.log(`\nGenerated: ${outputFile}`);
+}