@maxisoft/instantcms-mcp 1.2.3

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

@@ -0,0 +1,382 @@
+"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.generateFieldsMap = generateFieldsMap;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const TYPE_MAP = {
+    string: 'text',
+    number: 'number',
+    checkbox: 'boolean',
+    list: 'select',
+    listmultiple: 'multiselect',
+    textarea: 'text',
+    html: 'wysiwyg',
+    image: 'image',
+    file: 'file',
+    date: 'date',
+    datetime: 'datetime',
+    color: 'color',
+    hidden: 'hidden',
+    captcha: 'captcha',
+    user: 'user',
+    users: 'users',
+    category: 'category',
+    url: 'url',
+    email: 'email',
+    age: 'age',
+    child: 'child',
+    parent: 'parent',
+    toolbar: 'toolbar',
+    listbitmask: 'bitmask',
+    listgroups: 'groups',
+    fieldsgroup: 'fieldsgroup',
+    caption: 'caption',
+    forms: 'forms',
+    htmlcross: 'htmlcross',
+    htmlhint: 'htmlhint',
+    paypal: 'paypal',
+};
+function parseFieldFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const nameMatch = filePath.match(/([^\/]+)\.php$/);
+    if (!nameMatch)
+        return null;
+    const fileName = nameMatch[1];
+    const classMatch = content.match(/class\s+(field\w+)\s+extends\s+(\w+)/);
+    if (!classMatch)
+        return null;
+    const className = classMatch[1];
+    const isSystem = content.includes('public $is_system = true') || content.includes('public \\$is_system = true');
+    const titleMatch = content.match(/public\s+\$title\s*=\s*LANG_(\w+)/);
+    const title = titleMatch ? titleMatch[1].replace(/_/g, ' ').toLowerCase() : undefined;
+    const sqlMatch = content.match(/public\s+\$sql\s*=\s*['"]([^'"]+)['"]/);
+    const sqlTemplate = sqlMatch ? sqlMatch[1] : undefined;
+    const filterTypeMatch = content.match(/public\s+\$filter_type\s*=\s*['"](\w+)['"]/);
+    const filterType = filterTypeMatch ? filterTypeMatch[1] : undefined;
+    const filterHintMatch = content.match(/public\s+\$filter_hint\s*=\s*LANG_(\w+)/);
+    const filterHint = filterHintMatch
+        ? filterHintMatch[1].replace(/_/g, ' ').toLowerCase()
+        : undefined;
+    const varTypeMatch = content.match(/public\s+\$var_type\s*=\s*['"](\w+)['"]/);
+    const varType = varTypeMatch ? varTypeMatch[1] : undefined;
+    const allowIndexMatch = content.match(/public\s+\$allow_index\s*=\s*(true|false)/);
+    const allowIndex = allowIndexMatch ? allowIndexMatch[1] === 'true' : undefined;
+    const nativeTagMatch = content.match(/public\s+\$native_tag\s*=\s*(true|false)/);
+    const nativeTag = nativeTagMatch ? nativeTagMatch[1] === 'true' : undefined;
+    const dynamicListMatch = content.match(/public\s+\$dynamic_list\s*=\s*(true|false)/);
+    const dynamicList = dynamicListMatch ? dynamicListMatch[1] === 'true' : undefined;
+    const validationRules = [];
+    const getRulesMatch = content.match(/public\s+function\s+getRules\s*\(\s*\)\s*\{([\s\S]*?)\n\s*\}/);
+    if (getRulesMatch) {
+        const rulesBlock = getRulesMatch[1];
+        const ruleMatches = rulesBlock.matchAll(/\[\s*['"](\w+)['"]/g);
+        for (const match of ruleMatches) {
+            validationRules.push(match[1]);
+        }
+    }
+    const methods = {};
+    if (content.match(/public\s+function\s+parse\s*\(/))
+        methods.parse = true;
+    if (content.match(/public\s+function\s+store\s*\(/))
+        methods.store = true;
+    if (content.match(/public\s+function\s+getInput\s*\(/))
+        methods.getInput = true;
+    if (content.match(/public\s+function\s+applyFilter\s*\(/))
+        methods.applyFilter = true;
+    if (content.match(/public\s+function\s+getStringValue\s*\(/))
+        methods.getStringValue = true;
+    if (content.match(/public\s+function\s+getFilterInput\s*\(/))
+        methods.getFilterInput = true;
+    const options = [];
+    function extractOptionsBlock(content) {
+        const returnArray = content.indexOf('return array(');
+        let returnBracket = -1;
+        let searchFrom = 0;
+        while (true) {
+            returnBracket = content.indexOf('return [', searchFrom);
+            if (returnBracket < 0)
+                break;
+            if (content.substring(returnBracket, returnBracket + 9) === 'return []') {
+                searchFrom = returnBracket + 8;
+                continue;
+            }
+            break;
+        }
+        if (returnBracket < 0 && returnArray < 0)
+            return null;
+        if (returnBracket >= 0 && (returnArray < 0 || returnBracket < returnArray)) {
+            const start = content.indexOf('[', returnBracket) + 1;
+            if (start === 0)
+                return null;
+            let bracketCount = 1;
+            let end = start;
+            for (let i = start; i < content.length; i++) {
+                if (content[i] === '[')
+                    bracketCount++;
+                if (content[i] === ']') {
+                    bracketCount--;
+                    if (bracketCount === 0) {
+                        end = i;
+                        break;
+                    }
+                }
+                if (i > start + 15000)
+                    break;
+            }
+            return end > start ? content.substring(start, end) : null;
+        }
+        if (returnArray >= 0) {
+            const start = returnArray + 'return array('.length;
+            let end = start;
+            for (let i = start; i < content.length; i++) {
+                if (content[i] === ')' && content[i + 1] === ';') {
+                    end = i;
+                    break;
+                }
+                if (i > start + 15000)
+                    break;
+            }
+            return end > start ? content.substring(start, end) : null;
+        }
+        return null;
+    }
+    const optionsBlock = extractOptionsBlock(content);
+    if (optionsBlock) {
+        const fieldObjectMatches = optionsBlock.matchAll(/new\s+field(\w+)\s*\(\s*['"](\w+)['"]\s*,\s*\[([\s\S]*?)\]\s*\)/gi);
+        for (const match of fieldObjectMatches) {
+            const fieldType = match[1].toLowerCase();
+            const optionName = match[2];
+            const configBlock = match[3];
+            let optionDescription;
+            let defaultValue = undefined;
+            let required = false;
+            let extended = false;
+            let hint;
+            let visibleDepend;
+            let items;
+            const titleLangMatch = configBlock.match(/['"]title['"]\s*=>\s*LANG_(\w+)/);
+            if (titleLangMatch) {
+                optionDescription = titleLangMatch[1].replace(/_/g, ' ').toLowerCase();
+            }
+            const defaultMatch = configBlock.match(/['"]default['"]\s*=>\s*(\w+)/);
+            if (defaultMatch) {
+                defaultValue =
+                    defaultMatch[1] === 'true' ? true : defaultMatch[1] === 'false' ? false : defaultMatch[1];
+            }
+            const numberDefaultMatch = configBlock.match(/['"]default['"]\s*=>\s*(\d+)/);
+            if (numberDefaultMatch && !defaultMatch) {
+                defaultValue = parseInt(numberDefaultMatch[1], 10);
+            }
+            const requiredMatch = configBlock.match(/\['required'\]/);
+            if (requiredMatch) {
+                required = true;
+            }
+            const extendedMatch = configBlock.match(/['"]extended_option['"]\s*=>\s*(true|false)/);
+            if (extendedMatch) {
+                extended = extendedMatch[1] === 'true';
+            }
+            const hintMatch = configBlock.match(/['"]hint['"]\s*=>\s*LANG_(\w+)/);
+            if (hintMatch) {
+                hint = hintMatch[1].replace(/_/g, ' ').toLowerCase();
+            }
+            const visibleDependMatch = configBlock.match(/['"]visible_depend['"]\s*=>\s*\[([\s\S]*?)\]/);
+            if (visibleDependMatch) {
+                try {
+                    const dependStr = visibleDependMatch[1];
+                    const keyMatch = dependStr.match(/['"](\w+)['"]\s*=>\s*\[[\s\S]*?['"](\w+)['"][\s\S]*?\[[\s\S]*?['"](\d+)['"][\s\S]*?\]/);
+                    if (keyMatch) {
+                        visibleDepend = { [keyMatch[1]]: { [keyMatch[2]]: [keyMatch[3]] } };
+                    }
+                }
+                catch {
+                    // ignore parse errors for visible_depend
+                }
+            }
+            const staticItemsMatch = configBlock.match(/['"]items['"]\s*=>\s*\[([\s\S]*?)\]\s*/);
+            if (staticItemsMatch) {
+                items = {};
+                const itemMatches = staticItemsMatch[1].matchAll(/['"](\w+)['"]\s*=>\s*LANG_(\w+)/g);
+                for (const itemMatch of itemMatches) {
+                    items[itemMatch[1]] = itemMatch[2].replace(/_/g, ' ').toLowerCase();
+                }
+            }
+            const mappedType = TYPE_MAP[fieldType] || fieldType;
+            if (!options.find(o => o.name === optionName)) {
+                options.push({
+                    name: optionName,
+                    type: mappedType,
+                    description: optionDescription,
+                    default: defaultValue,
+                    required,
+                    extended,
+                    hint,
+                    visible_depend: Object.keys(visibleDepend || {}).length > 0 ? visibleDepend : undefined,
+                    items: Object.keys(items || {}).length > 0 ? items : undefined,
+                });
+            }
+        }
+    }
+    return {
+        name: fileName,
+        className,
+        filePath: filePath.replace(process.cwd(), ''),
+        hasOptions: options.length > 0,
+        isSystem,
+        options: options.length > 0 ? options : undefined,
+        title,
+        sqlTemplate,
+        filterType,
+        filterHint,
+        varType,
+        allowIndex,
+        nativeTag,
+        dynamicList,
+        validationRules: validationRules.length > 0 ? validationRules : undefined,
+        methods: Object.keys(methods).length > 0 ? methods : undefined,
+    };
+}
+function scanFieldsDir(dirPath, fields) {
+    if (!fs.existsSync(dirPath))
+        return;
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory())
+            continue;
+        if (entry.name.endsWith('.php')) {
+            const field = parseFieldFile(path.join(dirPath, entry.name));
+            if (field) {
+                fields.push(field);
+            }
+        }
+    }
+}
+function generateFieldsMap(sourceDir, outputPath) {
+    const fieldsDir = path.join(sourceDir, 'system', 'fields');
+    const fields = [];
+    scanFieldsDir(fieldsDir, fields);
+    fields.sort((a, b) => a.name.localeCompare(b.name));
+    const byName = {};
+    for (const field of fields) {
+        byName[field.name] = field;
+    }
+    const systemFields = fields.filter(f => f.isSystem);
+    const data = {
+        fields,
+        byName,
+        systemFields,
+        fieldCount: fields.length,
+        generatedAt: process.env.KNOWLEDGE_GENERATED_AT || new Date().toISOString(),
+    };
+    const typescriptContent = `// AUTO-GENERATED from source/system/fields
+// Do not edit manually - run 'npm run parse:fields' to regenerate
+
+export interface FieldOption {
+  name: string;
+  type: string;
+  description?: string;
+  default?: any;
+  required?: boolean;
+  extended?: boolean;
+  visible_depend?: Record<string, Record<string, string[]>>;
+  hint?: string;
+  items?: Record<string, string>;
+}
+
+export interface FieldInfo {
+  name: string;
+  className: string;
+  filePath: string;
+  hasOptions: boolean;
+  isSystem: boolean;
+  options?: FieldOption[];
+  description?: string;
+  title?: string;
+  sqlTemplate?: string;
+  filterType?: string;
+  filterHint?: string;
+  varType?: string;
+  allowIndex?: boolean;
+  nativeTag?: boolean;
+  dynamicList?: boolean;
+  validationRules?: string[];
+  methods?: {
+    parse?: boolean;
+    store?: boolean;
+    getInput?: boolean;
+    applyFilter?: boolean;
+    getStringValue?: boolean;
+    getFilterInput?: boolean;
+  };
+}
+
+export interface FieldsMap {
+  fields: FieldInfo[];
+  byName: Record<string, FieldInfo>;
+  systemFields: FieldInfo[];
+  fieldCount: number;
+  generatedAt: string;
+}
+
+export const fieldsMap: FieldsMap = ${JSON.stringify(data, null, 2)};
+
+export function getField(name: string): FieldInfo | undefined {
+  return fieldsMap.byName[name];
+}
+
+export function getFieldTypes(): string[] {
+  return fieldsMap.fields.map(f => f.name);
+}
+
+export function getSystemFields(): FieldInfo[] {
+  return fieldsMap.systemFields;
+}
+
+export function getFieldOptions(name: string): FieldOption[] | undefined {
+  return fieldsMap.byName[name]?.options;
+}
+
+export function getFieldBySqlTemplate(sql: string): FieldInfo | undefined {
+  return fieldsMap.fields.find(f => f.sqlTemplate?.includes(sql));
+}
+`;
+    fs.writeFileSync(outputPath, typescriptContent);
+    console.log(`Generated ${data.fieldCount} fields to ${outputPath}`);
+}
+if (require.main === module) {
+    const sourcePath = path.resolve(process.env.INSTANTCMS_SOURCE || 'source');
+    const outputPath = path.resolve('src/data/fields-map.ts');
+    generateFieldsMap(sourcePath, outputPath);
+}

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

@@ -0,0 +1,106 @@
+"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.discoverHooks = discoverHooks;
+exports.generateHooksSource = generateHooksSource;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const PHP_EXTENSIONS = new Set(['.php']);
+const HOOK_PATTERN = /(?:(cmsEventsManager)::(hook|hookAll)|(?:\$[a-zA-Z_][\w]*|\$this|\$controller)->(runHook))\(\s*(['"])([a-z][a-z0-9_]+)\4(?:\s*,\s*([^;\n]+))?/g;
+function walk(directory) {
+    if (!fs.existsSync(directory))
+        return [];
+    return fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            return walk(fullPath);
+        return PHP_EXTENSIONS.has(path.extname(entry.name)) ? [fullPath] : [];
+    });
+}
+function extractParameters(expression = '') {
+    const names = [...expression.matchAll(/\$[a-zA-Z_][\w]*/g)].map(match => match[0]);
+    return [...new Set(names)].slice(0, 20);
+}
+function discoverHooks(sourceRoot) {
+    const systemRoot = path.join(sourceRoot, 'system');
+    const discovered = new Map();
+    for (const filePath of walk(systemRoot)) {
+        const content = fs.readFileSync(filePath, 'utf8');
+        for (const match of content.matchAll(HOOK_PATTERN)) {
+            const name = match[5];
+            const prefix = content.slice(Math.max(0, match.index - 80), match.index);
+            const isFilter = /(?:return\s+|=\s*)$/.test(prefix.trimEnd());
+            const relativeFile = path.relative(sourceRoot, filePath).replaceAll(path.sep, '/');
+            const existing = discovered.get(name);
+            if (existing) {
+                existing.occurrences += 1;
+                if (!existing.files.includes(relativeFile))
+                    existing.files.push(relativeFile);
+                existing.parameters = [
+                    ...new Set([...existing.parameters, ...extractParameters(match[6])]),
+                ];
+                if (isFilter)
+                    existing.inferredType = 'filter';
+            }
+            else {
+                discovered.set(name, {
+                    name,
+                    inferredType: isFilter ? 'filter' : 'action',
+                    parameters: extractParameters(match[6]),
+                    files: [relativeFile],
+                    occurrences: 1,
+                });
+            }
+        }
+    }
+    return [...discovered.values()]
+        .map(hook => ({ ...hook, files: hook.files.sort() }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+function generateHooksSource(sourceRoot) {
+    const hooks = discoverHooks(sourceRoot);
+    return (`// Generated from official InstantCMS PHP hook calls. Do not edit.\n` +
+        `export interface SourceHookEvidence {\n` +
+        `  name: string;\n  inferredType: 'filter' | 'action';\n  parameters: string[];\n` +
+        `  files: string[];\n  occurrences: number;\n}\n\n` +
+        `export const sourceHooks: SourceHookEvidence[] = ${JSON.stringify(hooks, null, 2)};\n`);
+}
+if (require.main === module) {
+    const sourceRoot = path.resolve(process.env.INSTANTCMS_SOURCE || 'source');
+    const outputPath = path.resolve('src/generated/hooks-source.ts');
+    const output = generateHooksSource(sourceRoot);
+    fs.writeFileSync(outputPath, output);
+    console.log(`Generated ${discoverHooks(sourceRoot).length} source-backed hooks to ${outputPath}`);
+}

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

@@ -0,0 +1,197 @@
+"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.parseSqlFile = parseSqlFile;
+exports.generateDatabaseSchema = generateDatabaseSchema;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PREFIX_PLACEHOLDER = '{#}';
+function parseSqlFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const tables = [];
+    const statements = content.split(/DROP TABLE IF EXISTS.*?;/i);
+    for (const statement of statements) {
+        if (!statement.trim())
+            continue;
+        const createMatch = statement.match(/CREATE TABLE.*?\(([\s\S]*?)\)\s*ENGINE/i);
+        if (!createMatch)
+            continue;
+        const tableNameMatch = statement.match(/CREATE TABLE\s+`?([^`\s]+)`?\s*\(/i);
+        if (!tableNameMatch)
+            continue;
+        const tableName = tableNameMatch[1].replace(PREFIX_PLACEHOLDER, 'cms_');
+        const tableCommentMatch = statement.match(/COMMENT='([^']*)'/);
+        const tableComment = tableCommentMatch ? tableCommentMatch[1] : undefined;
+        const columnsBlock = createMatch[1];
+        const lines = columnsBlock.split(/,\s*\n/);
+        const fields = [];
+        const indexes = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            if (trimmed.startsWith('PRIMARY KEY') ||
+                trimmed.startsWith('UNIQUE KEY') ||
+                trimmed.startsWith('KEY')) {
+                const indexMatch = parseIndex(trimmed, tableName);
+                if (indexMatch) {
+                    indexes.push(indexMatch);
+                }
+                continue;
+            }
+            const fieldMatch = parseField(trimmed);
+            if (fieldMatch) {
+                fields.push(fieldMatch);
+            }
+        }
+        tables.push({
+            name: tableName,
+            comment: tableComment,
+            fields,
+            indexes,
+        });
+    }
+    return {
+        tables,
+        tableCount: tables.length,
+        generatedAt: process.env.KNOWLEDGE_GENERATED_AT || new Date().toISOString(),
+        sourceFile: path.basename(filePath),
+    };
+}
+function parseField(line) {
+    const match = line.match(/`?(\w+)`?\s+((?:ENUM\([^)]+\)|[\w()]+))(?:\s+(.+))?/i);
+    if (!match)
+        return null;
+    const name = match[1];
+    const type = match[2].toUpperCase();
+    const rest = match[3] || '';
+    const nullable = !rest.toUpperCase().includes('NOT NULL');
+    const defaultMatch = rest.match(/DEFAULT\s+('[^']*'|"[^"]*"|[^\s,]+)/i);
+    const commentMatch = rest.match(/COMMENT\s+'([^']*)'/i);
+    const keyMatch = rest.match(/(PRIMARY|UNIQUE)?\s*KEY/i);
+    let key;
+    if (keyMatch) {
+        if (keyMatch[1]?.toUpperCase() === 'PRIMARY')
+            key = 'PRI';
+        else if (keyMatch[0].toUpperCase().includes('UNIQUE'))
+            key = 'UNI';
+    }
+    const extraMatch = rest.match(/(AUTO_INCREMENT|ON UPDATE CURRENT_TIMESTAMP)/i);
+    return {
+        name,
+        type,
+        nullable,
+        default: defaultMatch ? defaultMatch[1].replace(/^['"]|['"]$/g, '') : undefined,
+        comment: commentMatch ? commentMatch[1] : undefined,
+        key,
+        extra: extraMatch ? extraMatch[1] : undefined,
+    };
+}
+function parseIndex(line, _tableName) {
+    const primaryMatch = line.match(/PRIMARY\s+KEY\s*\(([^)]+)\)/i);
+    if (primaryMatch) {
+        const fields = primaryMatch[1].split(',').map(f => f.trim().replace(/`/g, ''));
+        return { name: 'PRIMARY', fields };
+    }
+    const uniqueMatch = line.match(/UNIQUE\s+KEY\s+`?(\w+)`?\s*\(([^)]+)\)/i);
+    if (uniqueMatch) {
+        const fields = uniqueMatch[2].split(',').map(f => f.trim().replace(/`/g, ''));
+        return { name: uniqueMatch[1], fields, type: 'UNIQUE' };
+    }
+    const keyMatch = line.match(/KEY\s+`?(\w+)`?\s*\(([^)]+)\)/i);
+    if (keyMatch) {
+        const fields = keyMatch[2].split(',').map(f => f.trim().replace(/`/g, ''));
+        return { name: keyMatch[1], fields };
+    }
+    const fulltextMatch = line.match(/FULLTEXT\s+(?:KEY\s+)?`?(\w+)`?\s*\(([^)]+)\)/i);
+    if (fulltextMatch) {
+        const fields = fulltextMatch[2].split(',').map(f => f.trim().replace(/`/g, ''));
+        return { name: fulltextMatch[1], fields, type: 'FULLTEXT' };
+    }
+    return null;
+}
+function generateDatabaseSchema(sqlFilePath, outputPath) {
+    const schema = parseSqlFile(sqlFilePath);
+    const typescriptContent = `// AUTO-GENERATED from ${schema.sourceFile}
+// Do not edit manually - run 'npm run parse:database' to regenerate
+
+export interface DbField {
+  name: string;
+  type: string;
+  nullable: boolean;
+  default?: string;
+  comment?: string;
+  key?: 'PRI' | 'UNI' | 'MUL';
+  extra?: string;
+}
+
+export interface DbIndex {
+  name: string;
+  fields: string[];
+  type?: string;
+}
+
+export interface DbTable {
+  name: string;
+  comment?: string;
+  fields: DbField[];
+  indexes: DbIndex[];
+}
+
+export interface DatabaseSchema {
+  tables: DbTable[];
+  tableCount: number;
+  generatedAt: string;
+  sourceFile?: string;
+}
+
+export const databaseSchema: DatabaseSchema = ${JSON.stringify(schema, null, 2)};
+
+export function getTable(name: string): DbTable | undefined {
+  return databaseSchema.tables.find(t => t.name === name);
+}
+
+export function getTablesByPrefix(prefix: string): DbTable[] {
+  return databaseSchema.tables.filter(t => t.name.startsWith(prefix));
+}
+`;
+    fs.writeFileSync(outputPath, typescriptContent);
+    console.log(`Generated ${schema.tableCount} tables to ${outputPath}`);
+}
+if (require.main === module) {
+    const sqlPath = path.resolve(process.env.INSTANTCMS_SOURCE || 'source', 'install/languages/ru/sql/base.sql');
+    const outputPath = path.resolve('src/data/database-schema.ts');
+    generateDatabaseSchema(sqlPath, outputPath);
+}