worsoft-frontend-codegen-local-mcp 0.1.32 → 0.1.35

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.32';
+const SERVER_VERSION = '0.1.35';
 const PROTOCOL_VERSION = '2024-11-05';
 const TOOL_NAME = 'worsoft_codegen_local_generate_frontend';
 const STYLE_CATALOG_PATH = path.join(__dirname, 'assets', 'style-catalog.json');
@@ -148,14 +148,19 @@ export function createCrudSchema(
 const TOOL_SCHEMA = {
   type: 'object',
   properties: {
-    featureTitle: { type: 'string', description: 'Feature title from structured metadata.' },
-    tableName: { type: 'string', description: 'Target main table name from the structured feature metadata.' },
-    tableComment: { type: 'string', description: 'Main table comment or feature label for menu/title generation.' },
-    apiPath: { type: 'string', description: 'Backend API base path from structured metadata, for example iwmEmpOutsourcePerson.' },
-    style: { type: 'string', enum: Object.keys(STYLE_CATALOG), description: 'Style id from assets/style-catalog.json.' },
-    fields: {
-      type: 'array',
-      description: 'Structured main-table field metadata provided by the caller.',
+    featureTitle: { type: 'string', description: 'Feature title from pre-parsed structured metadata.' },
+    tableName: { type: 'string', description: 'Canonical main table name from PRD-aligned structured metadata.' },
+    tableComment: { type: 'string', description: 'Canonical main table comment or feature label from PRD-aligned structured metadata.' },
+    apiPath: { type: 'string', description: 'Backend API base path from pre-parsed structured metadata, for example iwmEmpOutsourcePerson.' },
+    pageType: {
+      type: 'string',
+      enum: ['feature', 'dictionary', 'non_standard', 'business', 'dict'],
+      description: 'Structured page type from parseResult. MCP consumes this value but does not derive it. Dictionary pages are restricted to dialog-based templates.',
+    },
+    style: { type: 'string', enum: Object.keys(STYLE_CATALOG), description: 'Final style id from parseResult or translated mcpPayload. MCP validates it but does not infer it.' },
+    fields: {
+      type: 'array',
+      description: 'Structured main-table field metadata already translated by the caller. MCP only consumes these low-level generation parameters.',
       items: {
         type: 'object',
         properties: {
@@ -172,8 +177,10 @@ const TOOL_SCHEMA = {
           queryType: { type: ['string', 'number'], description: 'Structured query type for list filtering, for example 20 for date ranges or 30 for dictionary filters.' },
           dictType: { type: 'string', description: 'Dictionary type code from structured metadata.' },
           defaultValue: { type: ['string', 'number', 'boolean'], description: 'Optional default value.' },
-          description: { type: 'string', description: 'Field description or notes.' },
-          sourceKind: { type: 'string', enum: ['entity', 'display', 'virtual', 'common'], description: 'Field source kind.' },
+          description: { type: 'string', description: 'Field description or notes.' },
+          componentType: { type: 'string', description: 'Explicit component type from PRD structured metadata, for example text, textarea, select, number or datetime.' },
+          formType: { type: 'string', description: 'Explicit form control type translated by the caller. MCP consumes this value first and only falls back to legacy heuristics when omitted.' },
+          sourceKind: { type: 'string', enum: ['entity', 'display', 'virtual', 'common'], description: 'Field source kind.' },
           primary: { type: ['boolean', 'string'], description: 'Whether the field is the primary key.' },
         },
         required: ['fieldName', 'label', 'type'],
@@ -182,7 +189,7 @@ const TOOL_SCHEMA = {
     },
     children: {
       type: 'array',
-      description: 'Optional direct child-table structures for master_child_jump. When provided, MCP renders all listed direct child tables on the same main form.',
+      description: 'Optional direct child-table structures for master_child_jump. When provided, MCP renders all listed direct child tables on the same main form. The caller must determine semantic truth before passing them in.',
       items: {
         type: 'object',
         properties: {
@@ -211,8 +218,10 @@ const TOOL_SCHEMA = {
                 queryType: { type: ['string', 'number'], description: 'Structured query type for list filtering, for example 20 for date ranges or 30 for dictionary filters.' },
                 dictType: { type: 'string', description: 'Dictionary type code from structured metadata.' },
                 defaultValue: { type: ['string', 'number', 'boolean'], description: 'Optional default value.' },
-                description: { type: 'string', description: 'Field description or notes.' },
-                sourceKind: { type: 'string', enum: ['entity', 'display', 'virtual', 'common'], description: 'Field source kind.' },
+                description: { type: 'string', description: 'Field description or notes.' },
+                componentType: { type: 'string', description: 'Explicit component type from PRD structured metadata.' },
+                formType: { type: 'string', description: 'Explicit form control type translated by the caller.' },
+                sourceKind: { type: 'string', enum: ['entity', 'display', 'virtual', 'common'], description: 'Field source kind.' },
                 primary: { type: ['boolean', 'string'], description: 'Whether the field is the primary key.' },
               },
               required: ['fieldName', 'label', 'type'],
@@ -238,8 +247,8 @@ const TOOL_SCHEMA = {
             items: {
               type: 'object',
               properties: {
-                tableName: { type: 'string', description: 'Module table name.' },
-                tableComment: { type: 'string', description: 'Module display label.' },
+                tableName: { type: 'string', description: 'Canonical module table name from PRD-aligned structured metadata.' },
+                tableComment: { type: 'string', description: 'Canonical module display label from PRD-aligned structured metadata.' },
                 apiPath: { type: 'string', description: 'Backend API base path for this module.' },
                 primaryKey: { type: 'string', description: 'Primary key field name. Defaults to id when omitted.' },
                 queryParentField: { type: 'string', description: 'Direct parent foreign key field used for page queries.' },
@@ -266,8 +275,10 @@ const TOOL_SCHEMA = {
                       queryType: { type: ['string', 'number'], description: 'Structured query type for list filtering, for example 20 for date ranges or 30 for dictionary filters.' },
                       dictType: { type: 'string', description: 'Dictionary type code from structured metadata.' },
                       defaultValue: { type: ['string', 'number', 'boolean'], description: 'Optional default value.' },
-                      description: { type: 'string', description: 'Field description or notes.' },
-                      sourceKind: { type: 'string', enum: ['entity', 'display', 'virtual', 'common'], description: 'Field source kind.' },
+                      description: { type: 'string', description: 'Field description or notes.' },
+                      componentType: { type: 'string', description: 'Explicit component type from PRD structured metadata.' },
+                      formType: { type: 'string', description: 'Explicit form control type translated by the caller.' },
+                      sourceKind: { type: 'string', enum: ['entity', 'display', 'virtual', 'common'], description: 'Field source kind.' },
                       primary: { type: ['boolean', 'string'], description: 'Whether the field is the primary key.' }
                     },
                     required: ['fieldName', 'label', 'type'],
@@ -845,15 +856,34 @@ function findDictType(comment) {
   return extractDictType(comment);
 }
 
-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 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 normalizeStructuredFormType(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!normalized) return '';
+  if (normalized === 'date') return 'date';
+  if (normalized === 'datetime') return 'datetime';
+  if (normalized === 'microme-operator') return 'number';
+  if (normalized === 'upload' || normalized === 'picker') {
+    throw new Error(
+      'Explicit component/form type "' +
+        normalized +
+        '" is not yet supported by worsoft-codegen-local templates. Please keep it in parseResult for downstream handling or extend MCP template support first.'
+    );
+  }
+  if (['text', 'select', 'textarea', 'number'].includes(normalized)) {
+    return normalized;
+  }
+  throw new Error('Unsupported explicit component/form type: ' + normalized);
+}
 
 function escapeForRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -1008,6 +1038,7 @@ function normalizeStructuredField(inputField, index, contextLabel) {
   }
 
   const { length, scale } = normalizeStructuredLengthAndScale(inputField.length, inputField.scale);
+  const explicitFormType = normalizeStructuredFormType(inputField.formType || inputField.componentType);
   const explicitQueryType =
     inputField.queryType === undefined || inputField.queryType === null || inputField.queryType === ''
       ? undefined
@@ -1023,6 +1054,7 @@ function normalizeStructuredField(inputField, index, contextLabel) {
     comment: label,
     label,
     description: String(inputField.description || '').trim(),
+    formType: explicitFormType,
     dictType: normalizeDictType(inputField.dictType),
     notNull: parseBooleanLike(inputField.required, false),
     defaultValue: normalizeDefaultValue(inputField.defaultValue),
@@ -1207,19 +1239,56 @@ function normalizeLevelsInput(inputLevels) {
   return levels;
 }
 
-function getStylePreset(styleId) {
-  const preset = STYLE_CATALOG[styleId];
-  if (!preset) throw new Error('Unsupported style: ' + styleId);
-  return preset;
-}
-
+function getStylePreset(styleId) {
+  const preset = STYLE_CATALOG[styleId];
+  if (!preset) throw new Error('Unsupported style: ' + styleId);
+  return preset;
+}
+
+function normalizePageTypeInput(pageType) {
+  if (pageType === undefined || pageType === null || pageType === '') return '';
+  const normalized = String(pageType).trim();
+  if (normalized === 'dict' || normalized === 'business') {
+    throw new Error(`Legacy pageType alias "${normalized}" is not allowed. Use canonical pageType "dictionary" or "feature" from parseResult.`);
+  }
+  if (['feature', 'dictionary', 'non_standard'].includes(normalized)) return normalized;
+  throw new Error('Unsupported pageType: ' + normalized);
+}
+
+function rejectSemanticStageInputs(input) {
+  const forbiddenKeys = [
+    'parseResult',
+    'prdFile',
+    'apiDocFile',
+    'fieldMappings',
+    'dictionaryMeta',
+    'listQueryMeta',
+    'fieldUiMeta',
+  ];
+  const present = forbiddenKeys.filter((key) => Object.prototype.hasOwnProperty.call(input, key));
+  if (present.length) {
+    throw new Error(`worsoft_codegen_local_generate_frontend only accepts translated low-level generation parameters. Unsupported semantic-stage keys: ${present.join(', ')}`);
+  }
+}
+
+function validatePageTypeAndStyle(pageType, style) {
+  if (!pageType) return;
+  if (pageType === 'non_standard') {
+    throw new Error('non_standard pages are not supported by worsoft_codegen_local_generate_frontend');
+  }
+  if (pageType !== 'dictionary') return;
+  if (style === 'single_table_jump' || style === 'master_child_jump') {
+    throw new Error(`Dictionary pages must use dialog-based styles. pageType=dictionary does not support style=${style}`);
+  }
+}
+
 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 normalizeFields(parsed) {
+  return parsed.fields.map((field) => ({ ...field, formType: field.formType || mapFieldType(field), isAudit: isAuditField(field.fieldName) }));
+}
 
 function ensureFieldExists(fields, fieldName, tableName, role) {
   const field = fields.find((item) => item.fieldName === fieldName);
@@ -1322,9 +1391,10 @@ function buildMultiLevelDictModel(safeArgs) {
 
   return {
     featureTitle: safeArgs.featureTitle || safeArgs.tableComment || parentModule.tableComment,
-    tableName: safeArgs.tableName,
+    tableName: safeArgs.tableName,
     tableComment: safeArgs.tableComment || parentModule.tableComment,
     apiPath: safeArgs.apiPath || parentModule.apiPath,
+    pageType: safeArgs.pageType || 'dictionary',
     className: toPascalCase(safeArgs.tableName || parentModule.tableName),
     functionName: resolvedTargets.functionName,
     moduleName: resolvedTargets.moduleName,
@@ -1419,6 +1489,7 @@ function buildModel(safeArgs) {
     tableName: safeArgs.tableName,
     tableComment: safeArgs.tableComment || safeArgs.featureTitle || safeArgs.tableName,
     apiPath,
+    pageType: safeArgs.pageType || '',
     className: toPascalCase(safeArgs.tableName),
     functionName: resolvedTargets.functionName,
     moduleName: resolvedTargets.moduleName,
@@ -2591,15 +2662,18 @@ function renderFiles(model, stylePreset, sharedSupport, localeZhSupport) {
   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] === undefined || input[key] === null || input[key] === '') throw new Error(key + ' is required');
-  }
+function ensureArguments(input) {
+  if (!input || typeof input !== 'object') throw new Error('Arguments must be an object');
+  rejectSemanticStageInputs(input);
+  for (const key of TOOL_SCHEMA.required) {
+    if (input[key] === undefined || input[key] === null || input[key] === '') throw new Error(key + ' is required');
+  }
 
-  const style = String(input.style);
-  getStylePreset(style);
-  const isMultiLevelDict = style === 'multi_level_dict';
+  const style = String(input.style);
+  const pageType = normalizePageTypeInput(input.pageType);
+  getStylePreset(style);
+  validatePageTypeAndStyle(pageType, style);
+  const isMultiLevelDict = style === 'multi_level_dict';
   const fields = isMultiLevelDict ? [] : normalizeStructuredFieldArray(input.fields, 'fields');
   const levels = isMultiLevelDict ? normalizeLevelsInput(input.levels) : [];
 
@@ -2616,7 +2690,8 @@ function ensureArguments(input) {
     tableName: String(input.tableName),
     tableComment: input.tableComment ? String(input.tableComment) : '',
     apiPath: normalizeApiPath(input.apiPath),
-    style,
+    pageType,
+    style,
     fields,
     levels,
     children: normalizeChildrenInput(input.children),
@@ -2659,6 +2734,7 @@ function buildManifest(model, safeArgs, stylePreset, files, note) {
     return {
       mode: 'local-template',
       style: safeArgs.style,
+      pageType: model.pageType || '',
       styleLabel: stylePreset.label,
       runtimeSupported: hasRuntimeSupport(stylePreset),
       tableName: model.tableName,
@@ -2712,10 +2788,11 @@ function buildManifest(model, safeArgs, stylePreset, files, note) {
   }));
   const selectedList = relations.map((relation) => formatRelationCandidate(relation));
 
-  return {
-    mode: 'local-template',
-    style: safeArgs.style,
-    styleLabel: stylePreset.label,
+  return {
+    mode: 'local-template',
+    style: safeArgs.style,
+    pageType: model.pageType || '',
+    styleLabel: stylePreset.label,
     runtimeSupported: hasRuntimeSupport(stylePreset),
     tableName: model.tableName,
     tableComment: model.tableComment,

package/package.json

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