worsoft-frontend-codegen-local-mcp 0.1.0

package/mcp_server.js

@@ -0,0 +1,1013 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SERVER_NAME = 'worsoft-codegen-local';
+const SERVER_VERSION = '0.1.0';
+const PROTOCOL_VERSION = '2024-11-05';
+const TOOL_NAME = 'worsoft_codegen_local_generate_frontend';
+const TEMPLATE_LIBRARY_ROOT = path.resolve(__dirname, '..', 'template');
+const STYLE_CATALOG_PATH = path.join(__dirname, 'assets', 'style-catalog.json');
+const DEFAULT_DESIGN_FILE = path.resolve(__dirname, '..', 'sql', 'SQL 设计说明.md');
+const STYLE_CATALOG = loadStyleCatalog();
+
+const TOOL_SCHEMA = {
+  type: 'object',
+  properties: {
+    designFile: { type: 'string', description: 'Absolute or relative Markdown design file path. Defaults to ../sql/SQL 设计说明.md when omitted.' },
+    tableName: { type: 'string', description: 'Target main table name from the design file.' },
+    style: { type: 'string', enum: Object.keys(STYLE_CATALOG), description: 'Style id from assets/style-catalog.json.' },
+    childTableName: { type: 'string', description: 'Optional child table name. In master_child_jump mode, this is the correction entry used to choose one child relation from the design file.' },
+    frontendPath: { type: 'string', description: 'Absolute frontend output root path.' },
+    moduleName: { type: 'string', description: 'Relative frontend module path, for example admin/test.' },
+    writeToDisk: { type: 'boolean', default: true, description: 'Whether to write generated files.' },
+    overwrite: { type: 'boolean', default: true, description: 'Whether to overwrite existing files. If false, existing files are skipped.' },
+  },
+  required: ['tableName', 'style', 'frontendPath'],
+  additionalProperties: false,
+};
+
+function loadStyleCatalog() {
+  return JSON.parse(fs.readFileSync(STYLE_CATALOG_PATH, 'utf8'));
+}
+
+function writeMessage(payload) {
+  process.stdout.write(JSON.stringify(payload) + '\n');
+}
+
+function successResponse(id, result) {
+  return { jsonrpc: '2.0', id, result };
+}
+
+function errorResponse(id, code, message) {
+  return { jsonrpc: '2.0', id, error: { code, message } };
+}
+
+function toolTextResult(text) {
+  return { content: [{ type: 'text', text }], isError: false };
+}
+
+function toCamelCase(value) {
+  return value.replace(/_([a-zA-Z0-9])/g, (_, letter) => letter.toUpperCase());
+}
+
+function toPascalCase(value) {
+  const camel = toCamelCase(value);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+function normalizeModuleName(moduleName) {
+  if (!moduleName) {
+    return 'admin/test';
+  }
+  return moduleName.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+}
+
+function isAuditField(fieldName) {
+  return [
+    'id',
+    'tenant_id',
+    'version',
+    'create_time',
+    'update_time',
+    'create_user_id',
+    'update_user_id',
+    'create_user',
+    'update_user',
+    'create_pos_id',
+    'create_pos',
+    'create_dpt_id',
+    'create_dpt',
+    'create_ogn_id',
+    'create_ogn',
+    'create_psm_full_id',
+    'create_psm_full_name',
+    'update_psm_full_id',
+    'update_psm_full_name',
+    'del_flag',
+  ].includes(fieldName);
+}
+
+function findDictType(comment) {
+  return extractDictType(comment);
+  const match = comment.match(/(?:字典|dict)[：:\s]*([a-zA-Z0-9_]+)/i);
+}
+
+function mapFieldType(field) {
+  if (field.dictType) return 'select';
+  if (field.sqlType === 'DATETIME' || field.sqlType === 'TIMESTAMP') return 'datetime';
+  if (field.sqlType === 'DATE') return 'date';
+  if (['INT', 'BIGINT', 'DECIMAL', 'NUMERIC'].includes(field.sqlType)) return 'number';
+  if (field.sqlType === 'TEXT') return 'textarea';
+  if (field.sqlType === 'VARCHAR' && field.length && Number(field.length) > 64) return 'textarea';
+  return 'text';
+}
+
+function escapeForRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function stripBom(text) {
+  return text.replace(/^\uFEFF/, '');
+}
+
+function readUtf8File(filePath) {
+  return stripBom(fs.readFileSync(filePath, 'utf8'));
+}
+
+function normalizeDictType(value) {
+  const normalized = String(value || '').trim();
+  if (!normalized || normalized === '-' || normalized === '/') {
+    return null;
+  }
+  return normalized.replace(/^['"`]+|['"`]+$/g, '');
+}
+
+function extractDictType(text) {
+  const normalized = String(text || '').trim();
+  if (!normalized) {
+    return null;
+  }
+
+  const patterns = [
+    /(?:字典|dict)(?:类型|type)?\s*[:：=]\s*([a-zA-Z0-9_-]+)/i,
+    /(?:字典|dict)(?:类型|type)?\s*[（(]\s*([a-zA-Z0-9_-]+)\s*[）)]/i,
+    /[（(]\s*(?:字典|dict)(?:类型|type)?\s*[:：=]?\s*([a-zA-Z0-9_-]+)\s*[）)]/i,
+  ];
+
+  for (const pattern of patterns) {
+    const match = normalized.match(pattern);
+    if (match && match[1]) {
+      return normalizeDictType(match[1]);
+    }
+  }
+
+  return null;
+}
+
+function resolveDictType(comment, explicitDictType) {
+  return normalizeDictType(explicitDictType) || extractDictType(comment);
+}
+
+function detectDictType(comment) {
+  return extractDictType(comment);
+  return findDictType(comment) || ((comment.match(/(?:字典|dict)\s*[:：\(（]?\s*([a-zA-Z0-9_]+)/i) || [])[1] ?? null);
+}
+
+function splitLength(value) {
+  const normalized = String(value || '').trim();
+  if (!normalized || normalized === '-' || normalized === '/') {
+    return { length: '', scale: '' };
+  }
+  const parts = normalized.split(',').map((item) => item.trim()).filter(Boolean);
+  return { length: parts[0] || '', scale: parts[1] || '' };
+}
+
+function normalizeDefaultValue(value) {
+  const normalized = String(value || '').trim();
+  if (!normalized || normalized === '-' || normalized === '/') {
+    return '';
+  }
+  return normalized;
+}
+
+function parseRequiredFlag(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return ['是', 'y', 'yes', '1', 'true', '必填'].includes(normalized);
+}
+
+function parseMarkdownRow(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('|')) return [];
+  return trimmed
+    .slice(1, trimmed.endsWith('|') ? -1 : undefined)
+    .split('|')
+    .map((cell) => cell.trim());
+}
+
+function isMarkdownSeparatorRow(cells) {
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell.replace(/\s+/g, '')));
+}
+
+function findHeaderIndex(headers, patterns) {
+  return headers.findIndex((header) => patterns.some((pattern) => pattern.test(header)));
+}
+
+function findPrimaryKeyFromText(text, fields) {
+  const quotedMatch = text.match(/PRIMARY\s+KEY\s*\(\s*`?([a-zA-Z0-9_]+)`?\s*\)/i);
+  if (quotedMatch) {
+    return quotedMatch[1];
+  }
+
+  const commentPk = fields.find((field) => /主键/i.test(field.comment));
+  if (commentPk) {
+    return commentPk.fieldName;
+  }
+
+  const idField = fields.find((field) => field.fieldName === 'id');
+  if (idField) {
+    return idField.fieldName;
+  }
+
+  return fields[0] ? fields[0].fieldName : null;
+}
+
+function parseMarkdownTableSection(tableName, tableComment, sectionLines) {
+  const firstTableLineIndex = sectionLines.findIndex((line) => line.trim().startsWith('|'));
+  if (firstTableLineIndex < 0) {
+    throw new Error('Could not find markdown field table for ' + tableName);
+  }
+
+  const tableLines = [];
+  for (let index = firstTableLineIndex; index < sectionLines.length; index += 1) {
+    const line = sectionLines[index].trim();
+    if (!line.startsWith('|')) break;
+    tableLines.push(line);
+  }
+
+  const rows = tableLines.map(parseMarkdownRow).filter((cells) => cells.length > 0);
+  if (rows.length < 3) {
+    throw new Error('Markdown field table is incomplete for ' + tableName);
+  }
+
+  const headers = rows[0];
+  const dataRows = rows.slice(1).filter((cells) => !isMarkdownSeparatorRow(cells));
+  const fieldNameIndex = findHeaderIndex(headers, [/字段名/, /列名/i, /field/i]);
+  const sqlTypeIndex = findHeaderIndex(headers, [/类型/, /数据类型/, /type/i]);
+  const lengthIndex = findHeaderIndex(headers, [/长度/, /精度/, /length/i]);
+  const requiredIndex = findHeaderIndex(headers, [/必填/, /必输/, /required/i]);
+  const defaultIndex = findHeaderIndex(headers, [/默认/, /default/i]);
+  const commentIndex = findHeaderIndex(headers, [/说明/, /备注/, /comment/i]);
+
+  const dictTypeIndex = findHeaderIndex(headers, [/字典/, /dict/i, /dict_?type/i]);
+
+  if (fieldNameIndex < 0 || sqlTypeIndex < 0) {
+    throw new Error('Markdown field table headers are missing required columns for ' + tableName);
+  }
+
+  const fields = [];
+  for (const row of dataRows) {
+    const fieldName = String(row[fieldNameIndex] || '').trim();
+    if (!fieldName || fieldName === '-') continue;
+
+    const sqlType = String(row[sqlTypeIndex] || '').trim().toUpperCase();
+    if (!sqlType) continue;
+
+    const lengthRaw = lengthIndex >= 0 ? row[lengthIndex] : '';
+    const comment = String(commentIndex >= 0 ? row[commentIndex] : '').trim() || fieldName;
+    const explicitDictType = dictTypeIndex >= 0 ? row[dictTypeIndex] : '';
+    const { length, scale } = splitLength(lengthRaw);
+
+    fields.push({
+      fieldName,
+      attrName: toCamelCase(fieldName),
+      sqlType,
+      length,
+      scale,
+      comment,
+      dictType: resolveDictType(comment, explicitDictType),
+      notNull: requiredIndex >= 0 ? parseRequiredFlag(row[requiredIndex]) : false,
+      defaultValue: defaultIndex >= 0 ? normalizeDefaultValue(row[defaultIndex]) : '',
+    });
+  }
+
+  if (!fields.length) {
+    throw new Error('No fields were parsed from markdown table ' + tableName);
+  }
+
+  const sectionText = sectionLines.join('\n');
+  const pkName = findPrimaryKeyFromText(sectionText, fields);
+  const pkField = fields.find((field) => field.fieldName === pkName) || fields[0];
+  return { pkField, fields, tableComment };
+}
+
+function parseMarkdownDesignTables(markdownText) {
+  const lines = stripBom(markdownText).replace(/\r\n?/g, '\n').split('\n');
+  const tables = new Map();
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const heading = lines[index].trim();
+    const headingMatch = heading.match(/^###\s+\S+\s+([a-zA-Z0-9_]+)\s*[\(（]([^)\n）]+)[\)）]/);
+    if (!headingMatch) continue;
+
+    const tableName = headingMatch[1];
+    const tableComment = headingMatch[2].trim();
+    const sectionLines = [];
+    let nextIndex = index + 1;
+    while (nextIndex < lines.length && !/^(##|###)\s+/.test(lines[nextIndex])) {
+      sectionLines.push(lines[nextIndex]);
+      nextIndex += 1;
+    }
+
+    tables.set(tableName, parseMarkdownTableSection(tableName, tableComment, sectionLines));
+    index = nextIndex - 1;
+  }
+
+  return tables;
+}
+
+function extractIdentifiersFromLine(line) {
+  return [...String(line || '').matchAll(/`?([a-zA-Z][a-zA-Z0-9_]*)`?/g)].map((match) => match[1]);
+}
+
+function stripMarkdownSyntax(text) {
+  return String(text || '')
+    .replace(/\*\*/g, '')
+    .replace(/`/g, '')
+    .replace(/\r\n?/g, '\n');
+}
+
+function parseMarkdownRelations(markdownText) {
+  const text = stripMarkdownSyntax(markdownText);
+  const blocks = [];
+  const headingRegex = /^(###|####)\s+(.+)$/gm;
+  let current = null;
+  let match = headingRegex.exec(text);
+
+  while (match) {
+    if (current) {
+      current.body = text.slice(current.start, match.index);
+      blocks.push(current);
+    }
+
+    current = {
+      title: match[2].trim(),
+      start: headingRegex.lastIndex,
+      body: '',
+    };
+    match = headingRegex.exec(text);
+  }
+
+  if (current) {
+    current.body = text.slice(current.start);
+    blocks.push(current);
+  }
+
+  const relations = [];
+  for (const block of blocks) {
+    const lines = block.body.split('\n').map((line) => line.trim()).filter(Boolean);
+    const mainLine = lines.find((line) => /(主表|父表)\s*[:：]/.test(line));
+    const childLine = lines.find((line) => /(从表|子表)\s*[:：]/.test(line));
+    const fieldLine = lines.find((line) => /关联字段\s*[:：]/.test(line));
+    if (!mainLine || !childLine || !fieldLine) continue;
+
+    const mainIdentifiers = extractIdentifiersFromLine(mainLine);
+    const childIdentifiers = extractIdentifiersFromLine(childLine);
+    const fieldIdentifiers = extractIdentifiersFromLine(fieldLine);
+    if (!mainIdentifiers.length || !childIdentifiers.length || fieldIdentifiers.length < 2) continue;
+
+    const relationTypeLine = lines.find((line) => /关系类型\s*[:：]/.test(line));
+    relations.push({
+      title: block.title,
+      mainTableName: mainIdentifiers[0],
+      childTableName: childIdentifiers[0],
+      childField: fieldIdentifiers[0],
+      mainField: fieldIdentifiers[1],
+      relationType: relationTypeLine ? relationTypeLine.split(/[:：]/).slice(1).join(':').trim() : '',
+    });
+  }
+
+  return relations;
+}
+
+function parseMarkdownDesignFile(markdownText) {
+  return {
+    tables: parseMarkdownDesignTables(markdownText),
+    relations: parseMarkdownRelations(markdownText),
+  };
+}
+
+function parseTableFromMarkdownDesign(designDoc, tableName) {
+  const parsed = designDoc.tables.get(tableName);
+  if (!parsed) {
+    throw new Error('Could not find table definition for ' + tableName + ' in Markdown design file');
+  }
+  return parsed;
+}
+
+function buildQuestionMarkSegmentRegex(segment) {
+  return new RegExp('^' + escapeForRegex(segment).replace(/\\\?/g, '.') + '$', 'i');
+}
+
+function tryResolveGarbledPath(resolvedPath) {
+  if (!resolvedPath.includes('?')) {
+    return null;
+  }
+
+  const parsed = path.parse(resolvedPath);
+  const segments = resolvedPath.slice(parsed.root.length).split(path.sep).filter(Boolean);
+  let currentPath = parsed.root;
+
+  for (const segment of segments) {
+    const exactPath = path.join(currentPath, segment);
+    if (fs.existsSync(exactPath)) {
+      currentPath = exactPath;
+      continue;
+    }
+
+    if (!segment.includes('?') || !fs.existsSync(currentPath) || !fs.statSync(currentPath).isDirectory()) {
+      return null;
+    }
+
+    const matcher = buildQuestionMarkSegmentRegex(segment);
+    const matches = fs.readdirSync(currentPath).filter((name) => matcher.test(name));
+    if (matches.length !== 1) {
+      throw new Error(
+        'Source file path could not be resolved uniquely from garbled input: ' +
+          resolvedPath +
+          '. Matched entries: ' +
+          (matches.length ? matches.join(', ') : 'none')
+      );
+    }
+
+    currentPath = path.join(currentPath, matches[0]);
+  }
+
+  return fs.existsSync(currentPath) ? currentPath : null;
+}
+
+function resolveSourcePath(inputPath) {
+  const resolvedPath = path.resolve(inputPath);
+  if (fs.existsSync(resolvedPath)) {
+    return resolvedPath;
+  }
+
+  const recoveredPath = tryResolveGarbledPath(resolvedPath);
+  if (recoveredPath) {
+    return recoveredPath;
+  }
+
+  throw new Error('Source file does not exist: ' + resolvedPath);
+}
+
+function formatRelationCandidate(relation) {
+  return {
+    childTableName: relation.childTableName,
+    mainField: relation.mainField,
+    childField: relation.childField,
+    relationType: relation.relationType || '',
+  };
+}
+
+function getRelationCandidates(designDoc, tableName) {
+  return designDoc.relations
+    .filter((relation) => relation.mainTableName === tableName)
+    .map(formatRelationCandidate);
+}
+
+function buildRetryArguments(safeArgs, sourceFile, childTableName) {
+  const retryArguments = {
+    tableName: safeArgs.tableName,
+    style: safeArgs.style,
+    frontendPath: safeArgs.frontendPath,
+    moduleName: safeArgs.moduleName,
+    writeToDisk: safeArgs.writeToDisk,
+    overwrite: safeArgs.overwrite,
+  };
+
+  if (sourceFile) {
+    retryArguments.designFile = sourceFile;
+  }
+
+  if (childTableName) {
+    retryArguments.childTableName = childTableName;
+  }
+
+  return retryArguments;
+}
+
+function buildRelationCorrectionEntry(safeArgs, sourceFile, candidates, selectedChildTableName) {
+  return {
+    field: 'childTableName',
+    title: '主子表关联修正入口',
+    tableName: safeArgs.tableName,
+    style: safeArgs.style,
+    designFile: sourceFile,
+    description: candidates.length
+      ? 'If the current child relation is not the one you want, pass childTableName to choose a candidate from the design file.'
+      : 'No child relation was found. Check the 主从表关联说明 section in the design file.',
+    currentValue: selectedChildTableName || '',
+    options: candidates.map((item) => item.childTableName),
+    candidates,
+    example: candidates.length ? buildRetryArguments(safeArgs, sourceFile, candidates[0].childTableName) : buildRetryArguments(safeArgs, sourceFile, selectedChildTableName),
+    retryArguments: candidates.map((item) => buildRetryArguments(safeArgs, sourceFile, item.childTableName)),
+  };
+}
+
+function createRelationResolutionError(message, safeArgs, sourceFile, candidates, selectedChildTableName, status) {
+  const error = new Error(message);
+  error.details = {
+    type: 'relation_resolution',
+    status,
+    tableName: safeArgs.tableName,
+    designFile: sourceFile,
+    message,
+    candidates,
+    correctionEntry: buildRelationCorrectionEntry(safeArgs, sourceFile, candidates, selectedChildTableName),
+  };
+  return error;
+}
+
+function loadSourceDocument(safeArgs) {
+  const inputPath = safeArgs.designFile || DEFAULT_DESIGN_FILE;
+  const sourcePath = resolveSourcePath(inputPath);
+  const text = readUtf8File(sourcePath);
+  return {
+    path: sourcePath,
+    text,
+    designDoc: parseMarkdownDesignFile(text),
+  };
+}
+
+function resolveMarkdownChildRelation(sourceDocument, safeArgs) {
+  let candidates = sourceDocument.designDoc.relations.filter((relation) => relation.mainTableName === safeArgs.tableName);
+  if (safeArgs.childTableName) {
+    candidates = candidates.filter((relation) => relation.childTableName === safeArgs.childTableName);
+  }
+
+  if (!candidates.length) {
+    const relationCandidates = getRelationCandidates(sourceDocument.designDoc, safeArgs.tableName);
+    const message = relationCandidates.length
+      ? 'Could not resolve child relation for main table ' + safeArgs.tableName + ' from Markdown design file.'
+      : 'No child relation was found for main table ' + safeArgs.tableName + ' in Markdown design file.';
+    throw createRelationResolutionError(message, safeArgs, sourceDocument.path, relationCandidates, safeArgs.childTableName, 'unresolved');
+  }
+
+  if (candidates.length > 1) {
+    const relationCandidates = candidates.map(formatRelationCandidate);
+    const message = 'Multiple child relations matched main table ' + safeArgs.tableName + '. Provide childTableName to disambiguate.';
+    throw createRelationResolutionError(message, safeArgs, sourceDocument.path, relationCandidates, safeArgs.childTableName, 'ambiguous');
+  }
+
+  return candidates[0];
+}
+
+function getStylePreset(styleId) {
+  const preset = STYLE_CATALOG[styleId];
+  if (!preset) throw new Error('Unsupported style: ' + styleId);
+  return preset;
+}
+
+function resolveSharedTemplates(stylePreset) {
+  const selected = {};
+  for (const [kind, templateName] of Object.entries(stylePreset.templateFiles || {})) {
+    const templatePath = path.join(TEMPLATE_LIBRARY_ROOT, templateName);
+    selected[kind] = { name: templateName, path: templatePath, exists: fs.existsSync(templatePath) };
+  }
+  return selected;
+}
+
+function hasRuntimeSupport(stylePreset) {
+  return Boolean(stylePreset.runtime && stylePreset.runtime.supported && stylePreset.runtime.templateDir);
+}
+
+function normalizeFields(parsed) {
+  return parsed.fields.map((field) => ({ ...field, formType: mapFieldType(field), isAudit: isAuditField(field.fieldName) }));
+}
+
+function ensureFieldExists(fields, fieldName, tableName, role) {
+  const field = fields.find((item) => item.fieldName === fieldName);
+  if (!field) throw new Error(role + ' field "' + fieldName + '" was not found on table ' + tableName);
+  return field;
+}
+
+function buildChildModel(sourceDocument, safeArgs, mainParsed) {
+  if (safeArgs.style !== 'master_child_jump') return null;
+
+  const relation = resolveMarkdownChildRelation(sourceDocument, safeArgs);
+  const childParsed = parseTableFromMarkdownDesign(sourceDocument.designDoc, relation.childTableName);
+  const childFields = normalizeFields(childParsed);
+  const mainRelationField = ensureFieldExists(mainParsed.fields, relation.mainField, safeArgs.tableName, 'Main relation');
+  const childRelationField = ensureFieldExists(childParsed.fields, relation.childField, relation.childTableName, 'Child relation');
+  const childVisibleFields = childFields.filter(
+    (field) => field.fieldName !== childParsed.pkField.fieldName && !field.isAudit && field.fieldName !== relation.childField
+  );
+
+  return {
+    tableName: relation.childTableName,
+    tableComment: childParsed.tableComment,
+    className: toPascalCase(relation.childTableName),
+    functionName: toCamelCase(relation.childTableName),
+    listName: toCamelCase(relation.childTableName) + 'List',
+    pk: childParsed.pkField,
+    fields: childFields,
+    visibleFields: childVisibleFields,
+    mainField: mainRelationField,
+    childField: childRelationField,
+    relationType: relation.relationType,
+  };
+}
+
+function buildModel(safeArgs) {
+  const sourceDocument = loadSourceDocument(safeArgs);
+  const mainParsed = parseTableFromMarkdownDesign(sourceDocument.designDoc, safeArgs.tableName);
+  const fields = normalizeFields(mainParsed);
+  const visibleFields = fields.filter((field) => field.fieldName !== mainParsed.pkField.fieldName && !field.isAudit);
+  const gridFields = visibleFields.slice(0, 8);
+  const dictTypes = [...new Set(visibleFields.map((field) => field.dictType).filter(Boolean))];
+  const child = buildChildModel(sourceDocument, safeArgs, mainParsed);
+
+  return {
+    sourceFile: sourceDocument.path,
+    designFile: sourceDocument.path,
+    tableName: safeArgs.tableName,
+    tableComment: mainParsed.tableComment,
+    className: toPascalCase(safeArgs.tableName),
+    functionName: toCamelCase(safeArgs.tableName),
+    moduleName: normalizeModuleName(safeArgs.moduleName),
+    pk: mainParsed.pkField,
+    fields,
+    visibleFields,
+    gridFields,
+    dictTypes,
+    frontendPath: path.resolve(safeArgs.frontendPath),
+    style: safeArgs.style,
+    child,
+  };
+}
+
+function renderTemplate(templateText, replacements) {
+  let output = templateText;
+  for (const [key, value] of Object.entries(replacements)) {
+    output = output.split('{{' + key + '}}').join(String(value));
+  }
+  return output;
+}
+
+function renderFormField(field) {
+  const label = field.comment.replace(/'/g, "\\'");
+  const prop = field.attrName;
+
+  if (field.formType === 'select') {
+    return [
+      '          <el-col :span="12" class="mb20">',
+      `            <el-form-item label="${label}" prop="${prop}">`,
+      `              <el-select v-model="form.${prop}" placeholder="Please select ${label}" style="width: 100%">`,
+      `                <el-option v-for="item in ${field.dictType}" :key="item.value" :label="item.label" :value="Number(item.value)" />`,
+      '              </el-select>',
+      '            </el-form-item>',
+      '          </el-col>',
+    ].join('\n');
+  }
+
+  if (field.formType === 'number') {
+    const max = field.comment.includes('%') || field.comment.includes('比例') ? ' :max="100"' : '';
+    const precision = field.sqlType === 'DECIMAL' && field.scale ? ` :precision="${field.scale}" :step="0.01"` : '';
+    return [
+      '          <el-col :span="12" class="mb20">',
+      `            <el-form-item label="${label}" prop="${prop}">`,
+      `              <el-input-number v-model="form.${prop}" :min="0"${max}${precision} placeholder="Please input ${label}" style="width: 100%" />`,
+      '            </el-form-item>',
+      '          </el-col>',
+    ].join('\n');
+  }
+
+  if (field.formType === 'datetime' || field.formType === 'date') {
+    const pickerType = field.formType === 'datetime' ? 'datetime' : 'date';
+    const formatName = field.formType === 'datetime' ? 'dateTimeStr' : 'dateStr';
+    return [
+      '          <el-col :span="12" class="mb20">',
+      `            <el-form-item label="${label}" prop="${prop}">`,
+      `              <el-date-picker type="${pickerType}" placeholder="Please select ${label}" v-model="form.${prop}" :value-format="${formatName}" style="width: 100%"></el-date-picker>`,
+      '            </el-form-item>',
+      '          </el-col>',
+    ].join('\n');
+  }
+
+  if (field.formType === 'textarea') {
+    return [
+      '          <el-col :span="24" class="mb20">',
+      `            <el-form-item label="${label}" prop="${prop}">`,
+      `              <el-input type="textarea" v-model="form.${prop}" placeholder="Please input ${label}" />`,
+      '            </el-form-item>',
+      '          </el-col>',
+    ].join('\n');
+  }
+
+  return [
+    '          <el-col :span="12" class="mb20">',
+    `            <el-form-item label="${label}" prop="${prop}">`,
+    `              <el-input v-model="form.${prop}" placeholder="Please input ${label}" />`,
+    '            </el-form-item>',
+    '          </el-col>',
+  ].join('\n');
+}
+
+function renderTableColumn(field) {
+  const label = field.comment.replace(/'/g, "\\'");
+  if (field.dictType) {
+    return [
+      `        <el-table-column prop="${field.attrName}" label="${label}" show-overflow-tooltip>`,
+      '          <template #default="scope">',
+      `            <dict-tag :options="${field.dictType}" :value="scope.row.${field.attrName}" />`,
+      '          </template>',
+      '        </el-table-column>',
+    ].join('\n');
+  }
+  return `        <el-table-column prop="${field.attrName}" label="${label}" show-overflow-tooltip />`;
+}
+
+function renderChildTableColumn(field, childListName) {
+  const label = field.comment.replace(/'/g, "\\'");
+  return [
+    `            <el-table-column label="${label}" prop="${field.attrName}">`,
+    '              <template #default="{ row, $index }">',
+    `                <el-form-item :prop="\`${childListName}.\${$index}.${field.attrName}\`" :rules="[{ required: true, trigger: 'blur' }]">`,
+    `                  <el-input v-model="row.${field.attrName}" />`,
+    '                </el-form-item>',
+    '              </template>',
+    '            </el-table-column>',
+  ].join('\n');
+}
+
+function renderOptionField(field) {
+  const label = field.comment.replace(/'/g, "\\'");
+  return `  ${field.attrName}: { show:true, alwaysHide:false, smart:false, label: '${label}', width: '120' },`;
+}
+
+function renderFilterType(field) {
+  if (!field.dictType) return null;
+  return `  ${field.attrName}: 30,`;
+}
+
+function renderDefaultLine(field) {
+  if (field.formType === 'number') return `  ${field.attrName}: 0,`;
+  return `  ${field.attrName}: '',`;
+}
+
+function renderFormDefaults(model) {
+  const lines = [`  ${model.pk.attrName}: '',`];
+  for (const field of model.visibleFields) lines.push(renderDefaultLine(field));
+  return lines.join('\n');
+}
+
+function renderChildTempDefaults(childModel) {
+  if (!childModel) return '';
+  return childModel.fields.map(renderDefaultLine).join('\n');
+}
+
+function renderDictImportBlock(dictTypes) {
+  if (!dictTypes.length) return '';
+  return [
+    "import { useDict } from '/@/hooks/dict';",
+    `const { ${dictTypes.join(', ')} } = useDict(${dictTypes.map((item) => `'${item}'`).join(', ')});`,
+  ].join('\n');
+}
+
+function renderValidationRule(field) {
+  if (!field.notNull) return null;
+  const label = field.comment.replace(/'/g, "\\'");
+  return `  ${field.attrName}: [{ required: true, message: '${label}不能为空', trigger: 'blur' }],`;
+}
+
+function renderFormRules(visibleFields) {
+  const lines = visibleFields.map(renderValidationRule).filter(Boolean);
+  return lines.join('\n');
+}
+
+function buildReplacements(model) {
+  const menuBaseId = Date.now();
+  const apiModulePath = `${model.moduleName}/${model.functionName}`;
+  const routePath = `${model.moduleName}/${model.functionName}`;
+  const permissionPrefix = `${model.moduleName}/${model.functionName}`.replace(/\//g, '_');
+  const formDictTypes = [...new Set(model.visibleFields.map((field) => field.dictType).filter(Boolean))];
+  const tableDictTypes = [...new Set(model.gridFields.map((field) => field.dictType).filter(Boolean))];
+
+  return {
+    TABLE_NAME: model.tableName,
+    TABLE_COMMENT: model.tableComment,
+    CLASS_NAME: model.className,
+    FUNCTION_NAME: model.functionName,
+    PK_ATTR: model.pk.attrName,
+    API_MODULE_PATH: apiModulePath,
+    API_PATH: apiModulePath,
+    VIEW_MODULE_PATH: routePath,
+    MENU_ROUTE_PATH: routePath,
+    PERMISSION_PREFIX: permissionPrefix,
+    MENU_BASE_ID: menuBaseId,
+    MENU_BASE_ID_PLUS_1: menuBaseId + 1,
+    MENU_BASE_ID_PLUS_2: menuBaseId + 2,
+    MENU_BASE_ID_PLUS_3: menuBaseId + 3,
+    MENU_BASE_ID_PLUS_4: menuBaseId + 4,
+    MENU_BASE_ID_PLUS_5: menuBaseId + 5,
+    GENERATED_AT: new Date().toISOString(),
+    FORM_FIELDS: model.visibleFields.map(renderFormField).join('\n'),
+    TABLE_COLUMNS: model.gridFields.map(renderTableColumn).join('\n'),
+    FORM_DEFAULTS: renderFormDefaults(model),
+    DICT_IMPORT_BLOCK: renderDictImportBlock(model.dictTypes),
+    FORM_DICT_IMPORT_BLOCK: renderDictImportBlock(formDictTypes),
+    TABLE_DICT_IMPORT_BLOCK: renderDictImportBlock(tableDictTypes),
+    OPTIONS_FIELDS: model.visibleFields.map(renderOptionField).join('\n'),
+    FILTER_TYPES: model.visibleFields.map(renderFilterType).filter(Boolean).join('\n'),
+    FORM_RULES: renderFormRules(model.visibleFields),
+    CHILD_CLASS_NAME: model.child ? model.child.className : '',
+    CHILD_LIST_NAME: model.child ? model.child.listName : '',
+    CHILD_PK_ATTR: model.child ? model.child.pk.attrName : '',
+    CHILD_RELATION_ATTR: model.child ? model.child.childField.attrName : '',
+    CHILD_TABLE_COLUMNS: model.child ? model.child.visibleFields.map((field) => renderChildTableColumn(field, model.child.listName)).join('\n') : '',
+    CHILD_TEMP_DEFAULTS: model.child ? renderChildTempDefaults(model.child) : '',
+  };
+}
+
+function renderFiles(model, stylePreset) {
+  if (!hasRuntimeSupport(stylePreset)) throw new Error('Runtime templates are not implemented for style: ' + model.style);
+
+  const runtime = stylePreset.runtime;
+  const templateDir = path.resolve(__dirname, runtime.templateDir);
+  const replacements = buildReplacements(model);
+  const formTemplate = fs.readFileSync(path.join(templateDir, runtime.files.form), 'utf8');
+  const listTemplate = fs.readFileSync(path.join(templateDir, runtime.files.list), 'utf8');
+  const optionsTemplate = fs.readFileSync(path.join(templateDir, runtime.files.options), 'utf8');
+  const apiTemplate = fs.readFileSync(path.join(templateDir, runtime.files.api), 'utf8');
+  const menuSqlTemplate = runtime.files.menuSql ? fs.readFileSync(path.join(templateDir, runtime.files.menuSql), 'utf8') : null;
+
+  const viewRoot = path.join(model.frontendPath, 'src', 'views', ...model.moduleName.split('/'), model.functionName);
+  const apiRoot = path.join(model.frontendPath, 'src', 'api', ...model.moduleName.split('/'));
+  const menuRoot = path.join(model.frontendPath, 'menu');
+
+  const files = [
+    { type: 'form', path: path.join(viewRoot, 'form.vue'), content: renderTemplate(formTemplate, replacements) },
+    { type: 'list', path: path.join(viewRoot, 'index.vue'), content: renderTemplate(listTemplate, replacements) },
+    { type: 'options', path: path.join(viewRoot, 'options.ts'), content: renderTemplate(optionsTemplate, replacements) },
+    { type: 'api', path: path.join(apiRoot, `${model.functionName}.ts`), content: renderTemplate(apiTemplate, replacements) },
+  ];
+
+  if (menuSqlTemplate) {
+    files.push({ type: 'menuSql', path: path.join(menuRoot, `${model.functionName}_menu.sql`), content: renderTemplate(menuSqlTemplate, replacements) });
+  }
+  return files;
+}
+
+function ensureArguments(input) {
+  if (!input || typeof input !== 'object') throw new Error('Arguments must be an object');
+  for (const key of TOOL_SCHEMA.required) {
+    if (!input[key]) throw new Error(key + ' is required');
+  }
+
+  const style = String(input.style);
+  getStylePreset(style);
+
+  return {
+    designFile: input.designFile ? String(input.designFile) : null,
+    tableName: String(input.tableName),
+    style,
+    childTableName: input.childTableName ? String(input.childTableName) : null,
+    frontendPath: String(input.frontendPath),
+    moduleName: input.moduleName ? String(input.moduleName) : 'admin/test',
+    writeToDisk: input.writeToDisk === undefined ? true : Boolean(input.writeToDisk),
+    overwrite: input.overwrite === undefined ? true : Boolean(input.overwrite),
+  };
+}
+
+function maybeWriteFiles(files, writeToDisk, overwrite) {
+  if (!writeToDisk) return;
+  for (const file of files) {
+    if (!overwrite && fs.existsSync(file.path)) {
+      file.status = 'skipped';
+      continue;
+    }
+    fs.mkdirSync(path.dirname(file.path), { recursive: true });
+    fs.writeFileSync(file.path, file.content, 'utf8');
+    file.status = 'success';
+  }
+}
+
+function buildManifest(model, safeArgs, stylePreset, sharedTemplates, files, note) {
+  const relationCandidates = getRelationCandidates(loadSourceDocument(safeArgs).designDoc, safeArgs.tableName);
+  return {
+    mode: 'local-template',
+    style: safeArgs.style,
+    styleLabel: stylePreset.label,
+    runtimeSupported: hasRuntimeSupport(stylePreset),
+    sourceFile: model.sourceFile,
+    designFile: model.designFile,
+    tableName: model.tableName,
+    tableComment: model.tableComment,
+    moduleName: model.moduleName,
+    writeToDisk: safeArgs.writeToDisk,
+    selectedTemplates: sharedTemplates,
+    files: files.map((file) => ({ type: file.type, path: file.path, bytes: Buffer.byteLength(file.content, 'utf8'), status: file.status || (safeArgs.writeToDisk ? 'success' : 'rendered') })),
+    relation: model.child
+      ? {
+          childTableName: model.child.tableName,
+          childTableComment: model.child.tableComment,
+          mainField: model.child.mainField.fieldName,
+          childField: model.child.childField.fieldName,
+          childListName: model.child.listName,
+          relationType: model.child.relationType || '',
+        }
+      : null,
+    relationResolution: model.child
+      ? {
+          status: 'resolved',
+          tableName: safeArgs.tableName,
+          designFile: model.designFile,
+          message: 'The relation was resolved from the design file. If you need another child table, use correctionEntry.retryArguments to resubmit.',
+          selected: formatRelationCandidate({
+            childTableName: model.child.tableName,
+            mainField: model.child.mainField.fieldName,
+            childField: model.child.childField.fieldName,
+            relationType: model.child.relationType || '',
+          }),
+          correctionEntry: buildRelationCorrectionEntry(safeArgs, model.designFile, relationCandidates, model.child.tableName),
+        }
+      : null,
+    summary: {
+      totalFields: model.fields.length,
+      visibleFields: model.visibleFields.length,
+      dictFields: model.visibleFields.filter((field) => field.dictType).map((field) => field.attrName),
+      skippedAuditFields: model.fields.filter((field) => field.isAudit).map((field) => field.fieldName),
+      childVisibleFields: model.child ? model.child.visibleFields.length : 0,
+    },
+    note,
+  };
+}
+
+async function handleToolCall(argumentsObject) {
+  const safeArgs = ensureArguments(argumentsObject);
+  const stylePreset = getStylePreset(safeArgs.style);
+  const model = buildModel(safeArgs);
+  const sharedTemplates = resolveSharedTemplates(stylePreset);
+
+  if (!hasRuntimeSupport(stylePreset)) {
+    const manifest = buildManifest(model, safeArgs, stylePreset, sharedTemplates, [], 'Style mapping is declared, but runtime template rendering is not implemented yet for this style.');
+    return toolTextResult(JSON.stringify(manifest, null, 2));
+  }
+
+  const files = renderFiles(model, stylePreset);
+  maybeWriteFiles(files, safeArgs.writeToDisk, safeArgs.overwrite);
+  const manifest = buildManifest(model, safeArgs, stylePreset, sharedTemplates, files, 'Runtime template rendering completed.');
+  return toolTextResult(JSON.stringify(manifest, null, 2));
+}
+
+async function onMessage(message) {
+  const { id, method, params } = message;
+  const isNotification = id === undefined || id === null;
+
+  if (method === 'initialize') {
+    writeMessage(successResponse(id, { protocolVersion: PROTOCOL_VERSION, capabilities: { tools: {} }, serverInfo: { name: SERVER_NAME, version: SERVER_VERSION } }));
+    return;
+  }
+
+  if (method === 'notifications/initialized') return;
+
+  // Silently ignore all other notifications (no id means no response expected).
+  if (isNotification) return;
+
+  if (method === 'ping') {
+    writeMessage(successResponse(id, {}));
+    return;
+  }
+
+  if (method === 'tools/list') {
+    writeMessage(successResponse(id, { tools: [{ name: TOOL_NAME, description: 'Generate Worsoft frontend files and menu SQL from a local Markdown design file with style-based local templates. In master_child_jump mode, relations are inferred from the Markdown design file.', inputSchema: TOOL_SCHEMA }] }));
+    return;
+  }
+
+  if (method === 'tools/call') {
+    if (!params || params.name !== TOOL_NAME) {
+      writeMessage(errorResponse(id, -32602, 'Unknown tool'));
+      return;
+    }
+    try {
+      const result = await handleToolCall(params.arguments || {});
+      writeMessage(successResponse(id, result));
+    } catch (error) {
+      const errorText = error && error.details ? JSON.stringify(error.details, null, 2) : String(error.message || error);
+      writeMessage(successResponse(id, { content: [{ type: 'text', text: errorText }], isError: true }));
+    }
+    return;
+  }
+
+  writeMessage(errorResponse(id, -32601, 'Method not found'));
+}
+
+function start() {
+  process.stdin.setEncoding('utf8');
+  let buffer = '';
+  process.stdin.on('data', (chunk) => {
+    buffer += chunk;
+    let newlineIndex = buffer.indexOf('\n');
+    while (newlineIndex >= 0) {
+      const raw = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (raw) {
+        try {
+          const message = JSON.parse(raw);
+          Promise.resolve(onMessage(message)).catch((error) => {
+            if (message && Object.prototype.hasOwnProperty.call(message, 'id')) {
+              writeMessage(errorResponse(message.id, -32603, error.message));
+            }
+          });
+        } catch (error) {
+          writeMessage(errorResponse(null, -32700, 'Parse error: ' + error.message));
+        }
+      }
+      newlineIndex = buffer.indexOf('\n');
+    }
+  });
+}
+
+start();