worsoft-frontend-codegen-local-mcp 0.1.3 → 0.1.4

package/README.md

@@ -24,6 +24,7 @@ This MCP generates Worsoft frontend files from a local Markdown design document.
 - `mainField` when `style=master_child_jump`: required
 - `childField` when `style=master_child_jump`: required
 - `relationType` when `style=master_child_jump`: optional
+- `children` when `style=master_child_jump`: optional array of direct child relations; when provided it overrides the legacy single-child fields
 
 ## Recommended MCP Arguments
 
@@ -57,6 +58,33 @@ Master-child:
 }
 ```
 
+Multi direct children on one main form:
+
+```json
+{
+  "tableName": "iwm_sys_trade_level",
+  "style": "master_child_jump",
+  "children": [
+    {
+      "childTableName": "iwm_sys_trade_level_standard",
+      "mainField": "id",
+      "childField": "trade_level_id",
+      "relationType": "1:N"
+    },
+    {
+      "childTableName": "iwm_sys_trade_level_competency",
+      "mainField": "id",
+      "childField": "trade_level_id",
+      "relationType": "1:N"
+    }
+  ],
+  "designFile": "plugins/sql/SQL 璁捐璇存槑.md",
+  "frontendPath": "E:/own-worker-platform/trunk/worsoft-ui",
+  "moduleName": "admin/test",
+  "writeToDisk": false
+}
+```
+
 ## Smoke Test
 
 PowerShell:
@@ -65,6 +93,7 @@ PowerShell:
 powershell -ExecutionPolicy Bypass -File plugins/worsoft-codegen-local/smoke_test_mcp.ps1 -Scenario single
 powershell -ExecutionPolicy Bypass -File plugins/worsoft-codegen-local/smoke_test_mcp.ps1 -Scenario master
 powershell -ExecutionPolicy Bypass -File plugins/worsoft-codegen-local/smoke_test_mcp.ps1 -Scenario child
+powershell -ExecutionPolicy Bypass -File plugins/worsoft-codegen-local/smoke_test_mcp.ps1 -Scenario multi
 powershell -ExecutionPolicy Bypass -File plugins/worsoft-codegen-local/smoke_test_mcp.ps1 -Scenario missing_relation
 ```
 
@@ -74,6 +103,7 @@ Node:
 node plugins/worsoft-codegen-local/smoke_test_mcp.js --scenario single
 node plugins/worsoft-codegen-local/smoke_test_mcp.js --scenario master
 node plugins/worsoft-codegen-local/smoke_test_mcp.js --scenario child
+node plugins/worsoft-codegen-local/smoke_test_mcp.js --scenario multi
 node plugins/worsoft-codegen-local/smoke_test_mcp.js --scenario missing_relation
 ```
 
@@ -95,9 +125,8 @@ For `master_child_jump`, MCP does not infer relations from the design file anymo
 
 The caller must provide:
 
-- `childTableName`
-- `mainField`
-- `childField`
+- either `children[]`
+- or the legacy single-child fields: `childTableName`, `mainField`, `childField`
 
 If these fields are missing, MCP returns `relation_input_required`.
 

package/assets/templates/master_child_jump/api.tpl

@@ -40,10 +40,10 @@ export function putObj(obj?: object) {
   });
 }
 
-export function delChildObj(ids?: object) {
+export function delChildObj(ids?: object, childTableName?: string) {
   return request({
     url: '/{{API_PATH}}/child',
     method: 'delete',
-    data: ids,
+    data: childTableName ? { ids, childTableName } : ids,
   });
 }

package/assets/templates/master_child_jump/form.tpl

@@ -9,9 +9,7 @@
 {{FORM_FIELDS}}
         </el-row>
         <el-row :gutter="24">
-          <sc-form-table v-model="form.{{CHILD_LIST_NAME}}" :addTemplate="childTemp" @delete="deleteChild" placeholder="暂无数据">
-{{CHILD_TABLE_COLUMNS}}
-          </sc-form-table>
+{{CHILD_SECTIONS}}
         </el-row>
       </el-form>
       <div class="dialog-footer" style="text-align: right; margin-top: 18px;">
@@ -38,12 +36,10 @@ const detail = ref(false);
 
 const form = reactive({
 {{FORM_DEFAULTS}}
-  {{CHILD_LIST_NAME}}: [],
+{{CHILD_FORM_LIST_DEFAULTS}}
 });
 
-const childTemp = reactive({
-{{CHILD_TEMP_DEFAULTS}}
-});
+{{CHILD_TEMP_DECLARATIONS}}
 
 const dataRules = ref({
 {{FORM_RULES}}
@@ -64,11 +60,11 @@ const get{{CLASS_NAME}}Data = async (id: string) => {
 const resetFormState = () => {
   Object.assign(form, {
 {{FORM_DEFAULTS}}
-    {{CHILD_LIST_NAME}}: [],
+{{CHILD_FORM_LIST_DEFAULTS}}
   });
   nextTick(() => {
     dataFormRef.value?.resetFields();
-    form.{{CHILD_LIST_NAME}} = [];
+{{CHILD_RESET_LISTS}}
   });
 };
 
@@ -113,10 +109,10 @@ const onSubmit = async () => {
   }
 };
 
-const deleteChild = async (obj: { {{CHILD_PK_ATTR}}: string }) => {
-  if (obj.{{CHILD_PK_ATTR}}) {
+const deleteChild = async (obj: Record<string, any>, childPkAttr: string, childTableName?: string) => {
+  if (obj[childPkAttr]) {
     try {
-      await delChildObj([obj.{{CHILD_PK_ATTR}}]);
+      await delChildObj([obj[childPkAttr]], childTableName);
       useMessage().success('删除成功');
     } catch (err: any) {
       useMessage().error(err.msg || '删除失败');

package/mcp_server.js

@@ -5,7 +5,7 @@ const fs = require('fs');
 const path = require('path');
 
 const SERVER_NAME = 'worsoft-codegen-local';
-const SERVER_VERSION = '0.1.3';
+const SERVER_VERSION = '0.1.4';
 const PROTOCOL_VERSION = '2024-11-05';
 const TOOL_NAME = 'worsoft_codegen_local_generate_frontend';
 const TEMPLATE_LIBRARY_ROOT = path.resolve(__dirname, '..', 'template');
@@ -19,6 +19,21 @@ const TOOL_SCHEMA = {
     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.' },
+    children: {
+      type: 'array',
+      description: 'Optional direct child-table relations for master_child_jump. When provided, MCP renders all listed direct child tables on the same main form.',
+      items: {
+        type: 'object',
+        properties: {
+          childTableName: { type: 'string', description: 'Child table name.' },
+          mainField: { type: 'string', description: 'Main table relation field.' },
+          childField: { type: 'string', description: 'Child table relation field.' },
+          relationType: { type: 'string', description: 'Optional relation type label, for example 1:N.' },
+        },
+        required: ['childTableName', 'mainField', 'childField'],
+        additionalProperties: false,
+      },
+    },
     childTableName: { type: 'string', description: 'Child table name. Required when style=master_child_jump.' },
     mainField: { type: 'string', description: 'Main table relation field. Required when style=master_child_jump.' },
     childField: { type: 'string', description: 'Child table relation field. Required when style=master_child_jump.' },
@@ -474,6 +489,15 @@ function buildRetryArguments(safeArgs, sourceFile, childTableName) {
     retryArguments.designFile = sourceFile;
   }
 
+  if (safeArgs.children && safeArgs.children.length) {
+    retryArguments.children = safeArgs.children.map((relation) => ({
+      childTableName: relation.childTableName,
+      mainField: relation.mainField,
+      childField: relation.childField,
+      relationType: relation.relationType || '',
+    }));
+  }
+
   if (childTableName) {
     retryArguments.childTableName = childTableName;
   }
@@ -536,13 +560,43 @@ function loadSourceDocument(safeArgs) {
   };
 }
 
-function resolveMarkdownChildRelation(sourceDocument, safeArgs) {
+function normalizeChildrenInput(inputChildren) {
+  if (inputChildren === undefined || inputChildren === null) {
+    return [];
+  }
+  if (!Array.isArray(inputChildren)) {
+    throw new Error('children must be an array');
+  }
+  return inputChildren.map((item, index) => {
+    if (!item || typeof item !== 'object') {
+      throw new Error('children[' + index + '] must be an object');
+    }
+    const childTableName = item.childTableName ? String(item.childTableName) : '';
+    const mainField = item.mainField ? String(item.mainField) : '';
+    const childField = item.childField ? String(item.childField) : '';
+    const relationType = item.relationType ? String(item.relationType) : '';
+    const missingFields = ['childTableName', 'mainField', 'childField'].filter((field) => !({ childTableName, mainField, childField })[field]);
+    if (missingFields.length) {
+      throw new Error('children[' + index + '] is missing required fields: ' + missingFields.join(', '));
+    }
+    return { childTableName, mainField, childField, relationType };
+  });
+}
+
+function resolveMarkdownChildRelations(sourceDocument, safeArgs) {
+  if (safeArgs.children && safeArgs.children.length) {
+    return safeArgs.children.map((relation) => ({
+      mainTableName: safeArgs.tableName,
+      childTableName: relation.childTableName,
+      mainField: relation.mainField,
+      childField: relation.childField,
+      relationType: relation.relationType || '',
+    }));
+  }
+
   const missingFields = ['childTableName', 'mainField', 'childField'].filter((field) => !safeArgs[field]);
   if (missingFields.length) {
-    const message =
-      'master_child_jump requires externally provided relation fields. Missing: ' +
-      missingFields.join(', ') +
-      '.';
+    const message = 'master_child_jump requires either children[] or legacy relation fields. Missing: ' + missingFields.join(', ') + '.';
     const error = new Error(message);
     error.details = {
       type: 'relation_input_required',
@@ -550,11 +604,19 @@ function resolveMarkdownChildRelation(sourceDocument, safeArgs) {
       tableName: safeArgs.tableName,
       designFile: sourceDocument.path,
       message,
-      requiredFields: ['childTableName', 'mainField', 'childField'],
+      requiredFields: ['children[] or childTableName/mainField/childField'],
       correctionEntry: {
-        fields: ['childTableName', 'mainField', 'childField'],
+        fields: ['children', 'childTableName', 'mainField', 'childField'],
         example: {
           ...buildRetryArguments(safeArgs, sourceDocument.path, safeArgs.childTableName || '<child_table_name>'),
+          children: [
+            {
+              childTableName: safeArgs.childTableName || '<child_table_name>',
+              mainField: safeArgs.mainField || '<main_field>',
+              childField: safeArgs.childField || '<child_field>',
+              relationType: safeArgs.relationType || '1:N',
+            },
+          ],
           mainField: safeArgs.mainField || '<main_field>',
           childField: safeArgs.childField || '<child_field>',
         },
@@ -563,13 +625,15 @@ function resolveMarkdownChildRelation(sourceDocument, safeArgs) {
     throw error;
   }
 
-  return {
-    mainTableName: safeArgs.tableName,
-    childTableName: safeArgs.childTableName,
-    mainField: safeArgs.mainField,
-    childField: safeArgs.childField,
-    relationType: safeArgs.relationType || '',
-  };
+  return [
+    {
+      mainTableName: safeArgs.tableName,
+      childTableName: safeArgs.childTableName,
+      mainField: safeArgs.mainField,
+      childField: safeArgs.childField,
+      relationType: safeArgs.relationType || '',
+    },
+  ];
 }
 
 function getStylePreset(styleId) {
@@ -601,31 +665,33 @@ function ensureFieldExists(fields, fieldName, tableName, role) {
   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 buildChildModels(sourceDocument, safeArgs, mainParsed) {
+  if (safeArgs.style !== 'master_child_jump') return [];
+
+  const relations = resolveMarkdownChildRelations(sourceDocument, safeArgs);
+  return relations.map((relation) => {
+    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) {
@@ -634,8 +700,8 @@ function buildModel(safeArgs) {
   const fields = normalizeFields(mainParsed);
   const visibleFields = fields.filter((field) => field.fieldName !== mainParsed.pkField.fieldName && !field.isAudit);
   const gridFields = visibleFields.slice(0, 8);
-  const child = buildChildModel(sourceDocument, safeArgs, mainParsed);
-  const childDictTypes = child ? child.visibleFields.map((field) => field.dictType).filter(Boolean) : [];
+  const children = buildChildModels(sourceDocument, safeArgs, mainParsed);
+  const childDictTypes = children.flatMap((child) => child.visibleFields.map((field) => field.dictType).filter(Boolean));
   const dictTypes = [...new Set([...visibleFields.map((field) => field.dictType).filter(Boolean), ...childDictTypes])];
 
   return {
@@ -653,7 +719,7 @@ function buildModel(safeArgs) {
     dictTypes,
     frontendPath: path.resolve(safeArgs.frontendPath),
     style: safeArgs.style,
-    child,
+    children,
   };
 }
 
@@ -792,6 +858,50 @@ function renderChildTempDefaults(childModel) {
   return childModel.fields.map(renderDefaultLine).join('\n');
 }
 
+function renderChildListDefaultLine(childModel) {
+  return `  ${childModel.listName}: [],`;
+}
+
+function renderChildTempDeclaration(childModel) {
+  return [
+    `const childTemp${childModel.className} = reactive({`,
+    renderChildTempDefaults(childModel),
+    '});',
+  ].join('\n');
+}
+
+function renderChildSection(childModel, childCount) {
+  const title = childModel.tableComment.replace(/'/g, "\\'");
+  const deleteExpression =
+    childCount > 1
+      ? `deleteChild(obj, '${childModel.pk.attrName}', '${childModel.tableName}')`
+      : `deleteChild(obj, '${childModel.pk.attrName}')`;
+
+  return [
+    '          <el-col :span="24" class="mb20">',
+    `            <div class="mb10" style="font-weight: 600;">${title}</div>`,
+    `            <sc-form-table v-model="form.${childModel.listName}" :addTemplate="childTemp${childModel.className}" @delete="(obj) => ${deleteExpression}" placeholder="暂无数据">`,
+    childModel.visibleFields.map((field) => renderChildTableColumn(field, childModel.listName)).join('\n'),
+    '            </sc-form-table>',
+    '          </el-col>',
+  ].join('\n');
+}
+
+function renderChildFormListDefaults(children) {
+  if (!children.length) return '';
+  return children.map(renderChildListDefaultLine).join('\n');
+}
+
+function renderChildTempDeclarations(children) {
+  if (!children.length) return '';
+  return children.map(renderChildTempDeclaration).join('\n\n');
+}
+
+function renderChildResetListLines(children) {
+  if (!children.length) return '';
+  return children.map((childModel) => `    form.${childModel.listName} = [];`).join('\n');
+}
+
 function renderDictImportBlock(dictTypes) {
   if (!dictTypes.length) return '';
   return [
@@ -846,12 +956,10 @@ function buildReplacements(model) {
     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) : '',
+    CHILD_FORM_LIST_DEFAULTS: renderChildFormListDefaults(model.children),
+    CHILD_TEMP_DECLARATIONS: renderChildTempDeclarations(model.children),
+    CHILD_RESET_LISTS: renderChildResetListLines(model.children),
+    CHILD_SECTIONS: model.children.map((childModel) => renderChildSection(childModel, model.children.length)).join('\n'),
   };
 }
 
@@ -897,6 +1005,7 @@ function ensureArguments(input) {
     designFile: input.designFile ? String(input.designFile) : null,
     tableName: String(input.tableName),
     style,
+    children: normalizeChildrenInput(input.children),
     childTableName: input.childTableName ? String(input.childTableName) : null,
     mainField: input.mainField ? String(input.mainField) : null,
     childField: input.childField ? String(input.childField) : null,
@@ -922,6 +1031,16 @@ function maybeWriteFiles(files, writeToDisk, overwrite) {
 }
 
 function buildManifest(model, safeArgs, stylePreset, sharedTemplates, files, note) {
+  const relations = model.children.map((childModel) => ({
+    childTableName: childModel.tableName,
+    childTableComment: childModel.tableComment,
+    mainField: childModel.mainField.fieldName,
+    childField: childModel.childField.fieldName,
+    childListName: childModel.listName,
+    relationType: childModel.relationType || '',
+  }));
+  const selectedList = relations.map((relation) => formatRelationCandidate(relation));
+
   return {
     mode: 'local-template',
     style: safeArgs.style,
@@ -935,32 +1054,23 @@ function buildManifest(model, safeArgs, stylePreset, sharedTemplates, files, not
     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
+    relation: relations.length === 1 ? relations[0] : null,
+    relations,
+    relationResolution: model.children.length
       ? {
           status: 'provided',
           tableName: safeArgs.tableName,
           designFile: model.designFile,
           source: 'arguments',
-          message: 'The relation was provided by the caller. MCP skipped design-doc relation inference and generated files directly.',
-          selected: formatRelationCandidate({
-            childTableName: model.child.tableName,
-            mainField: model.child.mainField.fieldName,
-            childField: model.child.childField.fieldName,
-            relationType: model.child.relationType || '',
-          }),
+          message:
+            model.children.length > 1
+              ? 'Direct child relations were provided by the caller. MCP skipped design-doc relation inference and generated a single main form with multiple child tables.'
+              : 'The relation was provided by the caller. MCP skipped design-doc relation inference and generated files directly.',
+          selected: selectedList.length === 1 ? selectedList[0] : null,
+          selectedList,
           correctionEntry: {
-            fields: ['childTableName', 'mainField', 'childField'],
-            example: buildRetryArguments(safeArgs, model.designFile, model.child.tableName),
+            fields: ['children', 'childTableName', 'mainField', 'childField'],
+            example: buildRetryArguments(safeArgs, model.designFile, model.children[0].tableName),
           },
         }
       : null,
@@ -969,7 +1079,9 @@ function buildManifest(model, safeArgs, stylePreset, sharedTemplates, files, not
       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,
+      childCount: model.children.length,
+      childTables: model.children.map((childModel) => childModel.tableName),
+      childVisibleFields: model.children.reduce((sum, childModel) => sum + childModel.visibleFields.length, 0),
     },
     note,
   };
@@ -1012,7 +1124,7 @@ async function onMessage(message) {
   }
 
   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, the caller must provide childTableName, mainField, and childField.', inputSchema: TOOL_SCHEMA }] }));
+    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, the caller must provide either children[] or childTableName/mainField/childField.', inputSchema: TOOL_SCHEMA }] }));
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worsoft-frontend-codegen-local-mcp",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Worsoft frontend local-template code generation MCP server.",
   "license": "UNLICENSED",
   "author": "worsoft <sw@worsoft.vip>",