worsoft-frontend-codegen-local-mcp 0.1.39 → 0.1.41

package/mcp_server.js

@@ -5,57 +5,57 @@ const fs = require('fs');
 const path = require('path');
 
 const SERVER_NAME = 'worsoft-codegen-local';
-const SERVER_VERSION = '0.1.39';
+const SERVER_VERSION = '0.1.41';
 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');
+const STYLE_CATALOG_PATH = path.join(__dirname, 'assets', 'style-catalog.json');
 const STYLE_CATALOG = loadStyleCatalog();
 const DEFAULT_DICT_REGISTRY_KEYS = {
   add_start_stop: 'COMMON_STATUS',
   trade_standard_type: 'TRADE_STANDARD_TYPE',
   trade_score_standard: 'TRADE_SCORE_STANDARD',
 };
-const DEFAULT_CRUD_SCHEMA_TEMPLATE = `export interface FieldMeta {
-  show: boolean;
-  listShow: boolean;
-  alwaysHide: boolean;
-  smart: boolean;
-  queryType?: number;
-  labelKey: string;
-  label?: string;
-  width: string;
-  dictType?: string;
-}
+const DEFAULT_CRUD_SCHEMA_TEMPLATE = `export interface FieldMeta {
+  show: boolean;
+  listShow: boolean;
+  alwaysHide: boolean;
+  smart: boolean;
+  queryType?: number;
+  labelKey: string;
+  label?: string;
+  width: string;
+  dictType?: string;
+}
 
 export interface FieldConfig {
   key: string;
   labelKey?: string;
   label?: string;
   width?: string;
-  show?: boolean;
-  listShow?: boolean;
-  alwaysHide?: boolean;
-  smart?: boolean;
-  queryType?: number;
-  dictType?: string;
-}
+  show?: boolean;
+  listShow?: boolean;
+  alwaysHide?: boolean;
+  smart?: boolean;
+  queryType?: number;
+  dictType?: string;
+}
 
 export interface CrudSchemaDefinition {
   master: FieldConfig[];
   children?: Record<string, FieldConfig[]>;
 }
 
-export interface CrudSchema {
-  master: Record<string, FieldMeta>;
-  children: Record<string, Record<string, FieldMeta>>;
-  smartNames: string[];
-  filterTypes: Record<string, number>;
-  childFilterTypes: Record<string, Record<string, number>>;
-  allDictTypes: string[];
-}
-
-const DEFAULT_WIDTH = '120';
-const DEFAULT_DICT_QUERY_TYPE = 30;
+export interface CrudSchema {
+  master: Record<string, FieldMeta>;
+  children: Record<string, Record<string, FieldMeta>>;
+  smartNames: string[];
+  filterTypes: Record<string, number>;
+  childFilterTypes: Record<string, Record<string, number>>;
+  allDictTypes: string[];
+}
+
+const DEFAULT_WIDTH = '120';
+const DEFAULT_DICT_QUERY_TYPE = 30;
 
 export const field = (labelKey: string, width = DEFAULT_WIDTH): FieldMeta => ({
   show: true,
@@ -71,17 +71,17 @@ export const dictField = (labelKey: string, dictType: string, width = DEFAULT_WI
   dictType,
 });
 
-export const buildFilterTypes = (fields: Record<string, FieldMeta>) =>
-  Object.fromEntries(
-    Object.entries(fields)
-      .filter(([, item]) => typeof item.queryType === 'number')
-      .map(([key, item]) => [key, item.queryType as number])
-  );
-
-export const buildSmartNames = (fields: Record<string, FieldMeta>) =>
-  Object.entries(fields)
-    .filter(([, item]) => item.smart)
-    .map(([key]) => key);
+export const buildFilterTypes = (fields: Record<string, FieldMeta>) =>
+  Object.fromEntries(
+    Object.entries(fields)
+      .filter(([, item]) => typeof item.queryType === 'number')
+      .map(([key, item]) => [key, item.queryType as number])
+  );
+
+export const buildSmartNames = (fields: Record<string, FieldMeta>) =>
+  Object.entries(fields)
+    .filter(([, item]) => item.smart)
+    .map(([key]) => key);
 
 export const collectDictTypes = (...groups: Array<Record<string, FieldMeta>>) =>
   Array.from(
@@ -94,19 +94,19 @@ export const collectDictTypes = (...groups: Array<Record<string, FieldMeta>>) =>
     )
   );
 
-const normalizeField = (item: FieldConfig): FieldMeta => ({
-  show: item.show ?? true,
-  listShow: item.listShow ?? item.show ?? true,
-  alwaysHide: item.alwaysHide ?? false,
-  smart: item.smart ?? false,
-  ...(typeof item.queryType === 'number'
-    ? { queryType: item.queryType }
-    : item.dictType && (item.listShow ?? item.show ?? true)
-      ? { queryType: DEFAULT_DICT_QUERY_TYPE }
-      : {}),
-  labelKey: item.labelKey ?? item.label ?? item.key,
-  ...(item.label ? { label: item.label } : {}),
-  width: item.width ?? DEFAULT_WIDTH,
+const normalizeField = (item: FieldConfig): FieldMeta => ({
+  show: item.show ?? true,
+  listShow: item.listShow ?? item.show ?? true,
+  alwaysHide: item.alwaysHide ?? false,
+  smart: item.smart ?? false,
+  ...(typeof item.queryType === 'number'
+    ? { queryType: item.queryType }
+    : item.dictType && (item.listShow ?? item.show ?? true)
+      ? { queryType: DEFAULT_DICT_QUERY_TYPE }
+      : {}),
+  labelKey: item.labelKey ?? item.label ?? item.key,
+  ...(item.label ? { label: item.label } : {}),
+  width: item.width ?? DEFAULT_WIDTH,
   ...(item.dictType ? { dictType: item.dictType } : {}),
 });
 
@@ -116,13 +116,13 @@ const toFieldMap = (fields: FieldConfig[]) =>
 const buildSchema = (
   master: Record<string, FieldMeta>,
   children: Record<string, Record<string, FieldMeta>> = {}
-): CrudSchema => ({
-  master,
-  children,
-  smartNames: buildSmartNames(master),
-  filterTypes: buildFilterTypes(master),
-  childFilterTypes: Object.fromEntries(
-    Object.entries(children).map(([key, fields]) => [key, buildFilterTypes(fields)])
+): CrudSchema => ({
+  master,
+  children,
+  smartNames: buildSmartNames(master),
+  filterTypes: buildFilterTypes(master),
+  childFilterTypes: Object.fromEntries(
+    Object.entries(children).map(([key, fields]) => [key, buildFilterTypes(fields)])
   ),
   allDictTypes: collectDictTypes(master, ...Object.values(children)),
 });
@@ -148,19 +148,19 @@ export function createCrudSchema(
 const TOOL_SCHEMA = {
   type: 'object',
   properties: {
-    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: ['business', 'dict', 'non_standard'],
-      description: 'Structured page type from parseResult. MCP consumes this value but does not derive it. Dict 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.',
+    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: ['business', 'dict', 'non_standard'],
+      description: 'Structured page type from parseResult. MCP consumes this value but does not derive it. Dict 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: {
@@ -170,17 +170,17 @@ const TOOL_SCHEMA = {
           length: { type: ['string', 'number'], description: 'Field length or precision string, for example 30 or 10,2.' },
           scale: { type: ['string', 'number'], description: 'Optional decimal scale.' },
           required: { type: ['boolean', 'string'], description: 'Whether the field is required.' },
-          readonly: { type: ['boolean', 'string'], description: 'Whether the field is readonly on the page.' },
-          show: { type: ['boolean', 'string'], description: 'Whether the field is shown on the page.' },
-          listShow: { type: ['boolean', 'string'], description: 'Whether the field is shown on the list page.' },
-          smart: { type: ['boolean', 'string'], description: 'Whether the field participates in smart keyword search. This must come from PRD, not inferred from type.' },
-          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.' },
+          readonly: { type: ['boolean', 'string'], description: 'Whether the field is readonly on the page.' },
+          show: { type: ['boolean', 'string'], description: 'Whether the field is shown on the page.' },
+          listShow: { type: ['boolean', 'string'], description: 'Whether the field is shown on the list page.' },
+          smart: { type: ['boolean', 'string'], description: 'Whether the field participates in smart keyword search. This must come from PRD, not inferred from type.' },
+          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.' },
-          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.' },
+          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'],
@@ -189,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. The caller must determine semantic truth before passing them in.',
+      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: {
@@ -197,7 +197,7 @@ const TOOL_SCHEMA = {
           childTableComment: { type: 'string', description: 'Child table comment or display label.' },
           mainField: { type: 'string', description: 'Main table relation field.' },
           childField: { type: 'string', description: 'Child table relation field.' },
-          payloadField: { type: 'string', description: 'Backend payload list field name from structured metadata, for example certificateList.' },
+          payloadField: { type: 'string', description: 'Backend payload list field name from structured metadata, for example certificateList.' },
           relationType: { type: 'string', description: 'Optional relation type label, for example 1:N.' },
           fields: {
             type: 'array',
@@ -211,17 +211,17 @@ const TOOL_SCHEMA = {
                 length: { type: ['string', 'number'], description: 'Field length or precision string.' },
                 scale: { type: ['string', 'number'], description: 'Optional decimal scale.' },
                 required: { type: ['boolean', 'string'], description: 'Whether the field is required.' },
-                readonly: { type: ['boolean', 'string'], description: 'Whether the field is readonly on the page.' },
-                show: { type: ['boolean', 'string'], description: 'Whether the field is shown on the page.' },
-                listShow: { type: ['boolean', 'string'], description: 'Whether the field is shown on the list page.' },
-                smart: { type: ['boolean', 'string'], description: 'Whether the field participates in smart keyword search. This must come from PRD, not inferred from type.' },
-                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.' },
+                readonly: { type: ['boolean', 'string'], description: 'Whether the field is readonly on the page.' },
+                show: { type: ['boolean', 'string'], description: 'Whether the field is shown on the page.' },
+                listShow: { type: ['boolean', 'string'], description: 'Whether the field is shown on the list page.' },
+                smart: { type: ['boolean', 'string'], description: 'Whether the field participates in smart keyword search. This must come from PRD, not inferred from type.' },
+                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.' },
-                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.' },
+                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'],
@@ -247,8 +247,8 @@ const TOOL_SCHEMA = {
             items: {
               type: 'object',
               properties: {
-                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.' },
+                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.' },
@@ -268,17 +268,17 @@ const TOOL_SCHEMA = {
                       length: { type: ['string', 'number'], description: 'Field length or precision string.' },
                       scale: { type: ['string', 'number'], description: 'Optional decimal scale.' },
                       required: { type: ['boolean', 'string'], description: 'Whether the field is required.' },
-                      readonly: { type: ['boolean', 'string'], description: 'Whether the field is readonly on the page.' },
-                      show: { type: ['boolean', 'string'], description: 'Whether the field is shown on the page.' },
-                      listShow: { type: ['boolean', 'string'], description: 'Whether the field is shown on the list page.' },
-                      smart: { type: ['boolean', 'string'], description: 'Whether the field participates in smart keyword search. This must come from PRD, not inferred from type.' },
-                      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.' },
+                      readonly: { type: ['boolean', 'string'], description: 'Whether the field is readonly on the page.' },
+                      show: { type: ['boolean', 'string'], description: 'Whether the field is shown on the page.' },
+                      listShow: { type: ['boolean', 'string'], description: 'Whether the field is shown on the list page.' },
+                      smart: { type: ['boolean', 'string'], description: 'Whether the field participates in smart keyword search. This must come from PRD, not inferred from type.' },
+                      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.' },
-                      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.' },
+                      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'],
@@ -294,34 +294,34 @@ const TOOL_SCHEMA = {
         required: ['levelIndex', 'modules'],
         additionalProperties: false
       }
-    },
-    frontendPath: { type: 'string', description: 'Absolute frontend output root path.' },
-    moduleName: { type: 'string', description: 'Relative frontend module path, for example admin/test.' },
-    targetViewDir: {
-      type: 'string',
-      description: 'Explicit relative target view directory under src/views, for example admin/iwmSysTrade. When provided, MCP writes directly to this directory instead of deriving the feature folder from tableName.',
-    },
-    targetApiModule: {
-      type: 'string',
-      description: 'Explicit relative api module path under src/api without extension, for example admin/iwmSysTrade. When provided, MCP writes the api file directly to this target path.',
-    },
-    targetI18nKey: {
-      type: 'string',
-      description: 'Explicit zh-cn i18n namespace, for example admin.iwmSysTrade. When provided, MCP writes zh-cn content to the matching file path and namespace instead of deriving them from moduleName and functionName.',
-    },
-    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.' },
-    writeSupportFiles: {
-      type: 'boolean',
-      default: true,
-      description: 'Whether to write project support files such as src/enums/dict-registry.ts and src/utils/crudSchema.ts.'
-    },
-    mergeI18nZh: {
-      type: 'boolean',
-      default: true,
-      description: 'Whether to merge generated zh-cn content into an existing i18n file. If false, MCP renders zh-cn.ts from current metadata only.'
-    },
-  },
+    },
+    frontendPath: { type: 'string', description: 'Absolute frontend output root path.' },
+    moduleName: { type: 'string', description: 'Relative frontend module path, for example admin/test.' },
+    targetViewDir: {
+      type: 'string',
+      description: 'Explicit relative target view directory under src/views, for example admin/iwmSysTrade. When provided, MCP writes directly to this directory instead of deriving the feature folder from tableName.',
+    },
+    targetApiModule: {
+      type: 'string',
+      description: 'Explicit relative api module path under src/api without extension, for example admin/iwmSysTrade. When provided, MCP writes the api file directly to this target path.',
+    },
+    targetI18nKey: {
+      type: 'string',
+      description: 'Explicit zh-cn i18n namespace, for example admin.iwmSysTrade. When provided, MCP writes zh-cn content to the matching file path and namespace instead of deriving them from moduleName and functionName.',
+    },
+    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.' },
+    writeSupportFiles: {
+      type: 'boolean',
+      default: true,
+      description: 'Whether to write project support files such as src/enums/dict-registry.ts and src/utils/crudSchema.ts.'
+    },
+    mergeI18nZh: {
+      type: 'boolean',
+      default: true,
+      description: 'Whether to merge generated zh-cn content into an existing i18n file. If false, MCP renders zh-cn.ts from current metadata only.'
+    },
+  },
   required: ['tableName', 'style', 'frontendPath'],
   additionalProperties: false,
 };
@@ -362,9 +362,9 @@ function normalizeModuleName(moduleName) {
   return moduleName.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
 }
 
-function normalizeModulePathForFeature(moduleName, functionName, apiPath) {
-  const normalized = normalizeModuleName(moduleName);
-  const segments = normalized.split('/').filter(Boolean);
+function normalizeModulePathForFeature(moduleName, functionName, apiPath) {
+  const normalized = normalizeModuleName(moduleName);
+  const segments = normalized.split('/').filter(Boolean);
   if (segments.length <= 1) {
     return normalized;
   }
@@ -379,73 +379,73 @@ function normalizeModulePathForFeature(moduleName, functionName, apiPath) {
   while (segments.length > 1 && duplicateNames.has(segments[segments.length - 1])) {
     segments.pop();
   }
-
-  return segments.join('/');
-}
-
-function normalizeExplicitTargetPath(targetPath, label) {
-  if (!targetPath) return '';
-  const normalized = normalizeModuleName(String(targetPath));
-  const segments = normalized.split('/').filter(Boolean);
-  if (segments.length < 2) {
-    throw new Error(`${label} must include parent path and feature name, for example admin/exampleFeature`);
-  }
-  return normalized;
-}
-
-function normalizeTargetI18nKey(targetI18nKey) {
-  if (!targetI18nKey) return '';
-  const normalized = String(targetI18nKey).trim().replace(/^\.|\.$/g, '');
-  const segments = normalized.split('.').filter(Boolean);
-  if (segments.length < 2) {
-    throw new Error('targetI18nKey must include parent namespace and feature name, for example admin.exampleFeature');
-  }
-  return segments.join('.');
-}
-
-function resolveGenerationTargets({ moduleName, functionName, apiPath, targetViewDir, targetApiModule, targetI18nKey }) {
-  const explicitViewDir = normalizeExplicitTargetPath(targetViewDir, 'targetViewDir');
-  const explicitApiModule = normalizeExplicitTargetPath(targetApiModule, 'targetApiModule');
-  const explicitI18nKey = normalizeTargetI18nKey(targetI18nKey);
-
-  const fallbackModuleName = normalizeModulePathForFeature(moduleName, functionName, apiPath);
-  const fallbackViewDir = [fallbackModuleName, functionName].filter(Boolean).join('/');
-  const fallbackApiModule = [fallbackModuleName, functionName].filter(Boolean).join('/');
-  const fallbackI18nKey = [fallbackModuleName, functionName].filter(Boolean).join('.').replace(/\//g, '.');
-
-  const finalViewDir = explicitViewDir || fallbackViewDir;
-  const viewSegments = finalViewDir.split('/').filter(Boolean);
-  const finalFunctionName = viewSegments[viewSegments.length - 1];
-  const finalModuleName = viewSegments.slice(0, -1).join('/');
-  const finalApiModule = explicitApiModule || [finalModuleName, finalFunctionName].filter(Boolean).join('/');
-  const finalI18nKey = explicitI18nKey || [finalModuleName, finalFunctionName].filter(Boolean).join('.');
-
-  return {
-    moduleName: finalModuleName,
-    functionName: finalFunctionName,
-    targetViewDir: finalViewDir,
-    targetApiModule: finalApiModule,
-    targetI18nKey: finalI18nKey,
-  };
-}
-
-function normalizeFrontendRootPath(frontendPath) {
-  const resolvedPath = path.resolve(String(frontendPath || ''));
-  const normalizedPath = resolvedPath.replace(/[\\/]+$/, '');
-  const baseName = path.basename(normalizedPath).toLowerCase();
-  if (baseName === 'src') {
-    return path.dirname(normalizedPath);
-  }
-  return normalizedPath;
-}
-
-function buildViewRoot(model) {
-  return path.join(model.frontendPath, 'src', 'views', ...model.targetViewDir.split('/').filter(Boolean));
-}
-
-function buildApiFilePath(model) {
-  return path.join(model.frontendPath, 'src', 'api', ...model.targetApiModule.split('/').filter(Boolean)) + '.ts';
-}
+
+  return segments.join('/');
+}
+
+function normalizeExplicitTargetPath(targetPath, label) {
+  if (!targetPath) return '';
+  const normalized = normalizeModuleName(String(targetPath));
+  const segments = normalized.split('/').filter(Boolean);
+  if (segments.length < 2) {
+    throw new Error(`${label} must include parent path and feature name, for example admin/exampleFeature`);
+  }
+  return normalized;
+}
+
+function normalizeTargetI18nKey(targetI18nKey) {
+  if (!targetI18nKey) return '';
+  const normalized = String(targetI18nKey).trim().replace(/^\.|\.$/g, '');
+  const segments = normalized.split('.').filter(Boolean);
+  if (segments.length < 2) {
+    throw new Error('targetI18nKey must include parent namespace and feature name, for example admin.exampleFeature');
+  }
+  return segments.join('.');
+}
+
+function resolveGenerationTargets({ moduleName, functionName, apiPath, targetViewDir, targetApiModule, targetI18nKey }) {
+  const explicitViewDir = normalizeExplicitTargetPath(targetViewDir, 'targetViewDir');
+  const explicitApiModule = normalizeExplicitTargetPath(targetApiModule, 'targetApiModule');
+  const explicitI18nKey = normalizeTargetI18nKey(targetI18nKey);
+
+  const fallbackModuleName = normalizeModulePathForFeature(moduleName, functionName, apiPath);
+  const fallbackViewDir = [fallbackModuleName, functionName].filter(Boolean).join('/');
+  const fallbackApiModule = [fallbackModuleName, functionName].filter(Boolean).join('/');
+  const fallbackI18nKey = [fallbackModuleName, functionName].filter(Boolean).join('.').replace(/\//g, '.');
+
+  const finalViewDir = explicitViewDir || fallbackViewDir;
+  const viewSegments = finalViewDir.split('/').filter(Boolean);
+  const finalFunctionName = viewSegments[viewSegments.length - 1];
+  const finalModuleName = viewSegments.slice(0, -1).join('/');
+  const finalApiModule = explicitApiModule || [finalModuleName, finalFunctionName].filter(Boolean).join('/');
+  const finalI18nKey = explicitI18nKey || [finalModuleName, finalFunctionName].filter(Boolean).join('.');
+
+  return {
+    moduleName: finalModuleName,
+    functionName: finalFunctionName,
+    targetViewDir: finalViewDir,
+    targetApiModule: finalApiModule,
+    targetI18nKey: finalI18nKey,
+  };
+}
+
+function normalizeFrontendRootPath(frontendPath) {
+  const resolvedPath = path.resolve(String(frontendPath || ''));
+  const normalizedPath = resolvedPath.replace(/[\\/]+$/, '');
+  const baseName = path.basename(normalizedPath).toLowerCase();
+  if (baseName === 'src') {
+    return path.dirname(normalizedPath);
+  }
+  return normalizedPath;
+}
+
+function buildViewRoot(model) {
+  return path.join(model.frontendPath, 'src', 'views', ...model.targetViewDir.split('/').filter(Boolean));
+}
+
+function buildApiFilePath(model) {
+  return path.join(model.frontendPath, 'src', 'api', ...model.targetApiModule.split('/').filter(Boolean)) + '.ts';
+}
 
 function toConstantCase(value) {
   return String(value || '')
@@ -569,12 +569,12 @@ function buildUniqueDictRegistryKey(dictType, usedKeys, existingByKey) {
   return candidate;
 }
 
-function buildI18nNamespaceSegments(model) {
-  if (model.targetI18nKey) {
-    return model.targetI18nKey.split('.').filter(Boolean);
-  }
-  return [...model.moduleName.split('/').filter(Boolean), model.functionName];
-}
+function buildI18nNamespaceSegments(model) {
+  if (model.targetI18nKey) {
+    return model.targetI18nKey.split('.').filter(Boolean);
+  }
+  return [...model.moduleName.split('/').filter(Boolean), model.functionName];
+}
 
 function buildI18nNamespace(model) {
   return buildI18nNamespaceSegments(model).join('.');
@@ -675,43 +675,43 @@ function buildZhCnLocaleObject(model) {
   return root;
 }
 
-function prepareZhCnLocaleFile(model, mergeExisting) {
-  const localeSegments = buildI18nNamespaceSegments(model);
-  const localePath = path.join(model.frontendPath, 'src', 'i18n', 'biz', ...localeSegments) + '.zh-cn.ts';
-  const exists = fs.existsSync(localePath);
-  const currentContent = exists ? readUtf8File(localePath) : '';
-  const generatedObject = buildZhCnLocaleObject(model);
-  const generatedContent = renderExportDefaultContent(generatedObject);
-
-  if (!mergeExisting) {
-    return {
-      path: localePath,
-      frontendPath: model.frontendPath,
-      exists,
-      isCompatible: true,
-      namespace: buildI18nNamespace(model),
-      content: generatedContent,
-      needsWrite: !exists || currentContent !== generatedContent,
-      mergeMode: 'replace',
-    };
-  }
-
-  const currentObject = exists ? parseExportDefaultObject(currentContent) : null;
-  const isCompatible = !exists || isPlainObject(currentObject);
-  const sanitizedCurrentObject = isCompatible ? removeFeatureCommonLocaleSections(currentObject || {}, model) : null;
-  const mergedObject = isCompatible ? deepMergeMissing(sanitizedCurrentObject || {}, generatedObject) : null;
-
-  return {
-    path: localePath,
-    frontendPath: model.frontendPath,
-    exists,
-    isCompatible,
-    namespace: buildI18nNamespace(model),
-    content: mergedObject ? renderExportDefaultContent(mergedObject) : '',
-    needsWrite: !exists || (isCompatible && renderExportDefaultContent(currentObject || {}) !== renderExportDefaultContent(mergedObject)),
-    mergeMode: 'merge',
-  };
-}
+function prepareZhCnLocaleFile(model, mergeExisting) {
+  const localeSegments = buildI18nNamespaceSegments(model);
+  const localePath = path.join(model.frontendPath, 'src', 'i18n', 'biz', ...localeSegments) + '.zh-cn.ts';
+  const exists = fs.existsSync(localePath);
+  const currentContent = exists ? readUtf8File(localePath) : '';
+  const generatedObject = buildZhCnLocaleObject(model);
+  const generatedContent = renderExportDefaultContent(generatedObject);
+
+  if (!mergeExisting) {
+    return {
+      path: localePath,
+      frontendPath: model.frontendPath,
+      exists,
+      isCompatible: true,
+      namespace: buildI18nNamespace(model),
+      content: generatedContent,
+      needsWrite: !exists || currentContent !== generatedContent,
+      mergeMode: 'replace',
+    };
+  }
+
+  const currentObject = exists ? parseExportDefaultObject(currentContent) : null;
+  const isCompatible = !exists || isPlainObject(currentObject);
+  const sanitizedCurrentObject = isCompatible ? removeFeatureCommonLocaleSections(currentObject || {}, model) : null;
+  const mergedObject = isCompatible ? deepMergeMissing(sanitizedCurrentObject || {}, generatedObject) : null;
+
+  return {
+    path: localePath,
+    frontendPath: model.frontendPath,
+    exists,
+    isCompatible,
+    namespace: buildI18nNamespace(model),
+    content: mergedObject ? renderExportDefaultContent(mergedObject) : '',
+    needsWrite: !exists || (isCompatible && renderExportDefaultContent(currentObject || {}) !== renderExportDefaultContent(mergedObject)),
+    mergeMode: 'merge',
+  };
+}
 
 function prepareDictRegistry(frontendPath, dictTypes) {
   const registryPath = path.join(frontendPath, 'src', 'enums', 'dict-registry.ts');
@@ -765,46 +765,46 @@ function ensureDirectory(filePath) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
 
-function writeSupportFile(filePath, content) {
-  ensureDirectory(filePath);
-  fs.writeFileSync(filePath, content, 'utf8');
-}
-
-function buildVirtualDictRegistry(dictTypes) {
-  const normalizedDictTypes = [...new Set((dictTypes || []).filter(Boolean))];
-  const entries = normalizedDictTypes.map((dictType) => ({ key: getPreferredDictRegistryKey(dictType), value: dictType }));
-  return {
-    path: '',
-    entries,
-    keyByValue: new Map(entries.map((entry) => [entry.value, entry.key])),
-    needsWrite: false,
-    writeEnabled: false,
-  };
-}
-
-function prepareSharedSupport(frontendPath, dictTypes, writeSupportFiles) {
-  const normalizedDictTypes = [...new Set((dictTypes || []).filter(Boolean))];
-  const dictRegistry = writeSupportFiles ? prepareDictRegistry(frontendPath, normalizedDictTypes) : buildVirtualDictRegistry(normalizedDictTypes);
-  const crudSchemaPath = path.join(frontendPath, 'src', 'utils', 'crudSchema.ts');
-  const crudSchema = writeSupportFiles
-    ? ensureCrudSchemaSupportFile(frontendPath)
-    : {
-        path: crudSchemaPath,
-        content: DEFAULT_CRUD_SCHEMA_TEMPLATE,
-        exists: fs.existsSync(crudSchemaPath),
-        isCompatible: true,
-        needsWrite: false,
-        writeEnabled: false,
-      };
-  return {
-    dictRegistry,
-    crudSchema,
-    writeEnabled: Boolean(writeSupportFiles),
-  };
-}
-
-function maybeWriteSharedSupport(sharedSupport, writeToDisk) {
-  if (!writeToDisk || !sharedSupport.writeEnabled) return;
+function writeSupportFile(filePath, content) {
+  ensureDirectory(filePath);
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+function buildVirtualDictRegistry(dictTypes) {
+  const normalizedDictTypes = [...new Set((dictTypes || []).filter(Boolean))];
+  const entries = normalizedDictTypes.map((dictType) => ({ key: getPreferredDictRegistryKey(dictType), value: dictType }));
+  return {
+    path: '',
+    entries,
+    keyByValue: new Map(entries.map((entry) => [entry.value, entry.key])),
+    needsWrite: false,
+    writeEnabled: false,
+  };
+}
+
+function prepareSharedSupport(frontendPath, dictTypes, writeSupportFiles) {
+  const normalizedDictTypes = [...new Set((dictTypes || []).filter(Boolean))];
+  const dictRegistry = writeSupportFiles ? prepareDictRegistry(frontendPath, normalizedDictTypes) : buildVirtualDictRegistry(normalizedDictTypes);
+  const crudSchemaPath = path.join(frontendPath, 'src', 'utils', 'crudSchema.ts');
+  const crudSchema = writeSupportFiles
+    ? ensureCrudSchemaSupportFile(frontendPath)
+    : {
+        path: crudSchemaPath,
+        content: DEFAULT_CRUD_SCHEMA_TEMPLATE,
+        exists: fs.existsSync(crudSchemaPath),
+        isCompatible: true,
+        needsWrite: false,
+        writeEnabled: false,
+      };
+  return {
+    dictRegistry,
+    crudSchema,
+    writeEnabled: Boolean(writeSupportFiles),
+  };
+}
+
+function maybeWriteSharedSupport(sharedSupport, writeToDisk) {
+  if (!writeToDisk || !sharedSupport.writeEnabled) return;
 
   if (sharedSupport.crudSchema.needsWrite) {
     writeSupportFile(sharedSupport.crudSchema.path, sharedSupport.crudSchema.content);
@@ -815,35 +815,35 @@ function maybeWriteSharedSupport(sharedSupport, writeToDisk) {
   }
 }
 
-function buildSupportNote(sharedSupport, localeZhSupport) {
-  const notes = [];
-
-  if (!sharedSupport.writeEnabled) {
-    notes.push(
-      'Shared support file writing is disabled. Generated code still references src/utils/crudSchema.ts and may reference src/enums/dict-registry.ts, so those helpers must already exist in the target project.'
-    );
-  }
-
-  if (sharedSupport.crudSchema.exists && !sharedSupport.crudSchema.isCompatible) {
-    notes.push(
-      'Detected an existing src/utils/crudSchema.ts that does not match the expected helper signature. ' +
-        'MCP preserved the existing file and did not overwrite it. Generated pages now depend on that file being manually aligned.'
+function buildSupportNote(sharedSupport, localeZhSupport) {
+  const notes = [];
+
+  if (!sharedSupport.writeEnabled) {
+    notes.push(
+      'Shared support file writing is disabled. Generated code still references src/utils/crudSchema.ts and may reference src/enums/dict-registry.ts, so those helpers must already exist in the target project.'
+    );
+  }
+
+  if (sharedSupport.crudSchema.exists && !sharedSupport.crudSchema.isCompatible) {
+    notes.push(
+      'Detected an existing src/utils/crudSchema.ts that does not match the expected helper signature. ' +
+        'MCP preserved the existing file and did not overwrite it. Generated pages now depend on that file being manually aligned.'
     );
   }
 
-  if (localeZhSupport.exists && !localeZhSupport.isCompatible) {
-    notes.push(
-      `Detected an existing ${path.relative(localeZhSupport.frontendPath, localeZhSupport.path).replace(/\\/g, '/')} that MCP could not parse. ` +
-        'The file was preserved and not updated, so new Chinese i18n keys may need to be merged manually.'
-    );
-  }
-
-  if (localeZhSupport.mergeMode === 'replace') {
-    notes.push('zh-cn.ts merge is disabled. MCP rendered the Chinese locale file from current metadata only.');
-  }
-
-  return notes.length ? notes.join(' ') : 'Runtime template rendering completed.';
-}
+  if (localeZhSupport.exists && !localeZhSupport.isCompatible) {
+    notes.push(
+      `Detected an existing ${path.relative(localeZhSupport.frontendPath, localeZhSupport.path).replace(/\\/g, '/')} that MCP could not parse. ` +
+        'The file was preserved and not updated, so new Chinese i18n keys may need to be merged manually.'
+    );
+  }
+
+  if (localeZhSupport.mergeMode === 'replace') {
+    notes.push('zh-cn.ts merge is disabled. MCP rendered the Chinese locale file from current metadata only.');
+  }
+
+  return notes.length ? notes.join(' ') : 'Runtime template rendering completed.';
+}
 
 function getDictRegistryReference(dictType, keyByValue) {
   if (!dictType) return '';
@@ -861,34 +861,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 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 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, '\\$&');
@@ -1000,6 +1000,28 @@ function normalizeApiPath(value) {
     .replace(/\/+$/, '');
 }
 
+function buildApiRoutePath(moduleName, apiPath) {
+  const normalizedApiPath = normalizeApiPath(apiPath);
+  if (!normalizedApiPath) return '';
+
+  const normalizedModuleName = normalizeModuleName(moduleName || '')
+    .split('/')
+    .filter(Boolean);
+  const apiSegments = normalizedApiPath.split('/').filter(Boolean);
+
+  if (!normalizedModuleName.length) {
+    return '/' + apiSegments.join('/');
+  }
+
+  const modulePrefix = normalizedModuleName.join('/');
+  const currentApiPath = apiSegments.join('/');
+  if (currentApiPath === modulePrefix || currentApiPath.startsWith(modulePrefix + '/')) {
+    return '/' + currentApiPath;
+  }
+
+  return '/' + [...normalizedModuleName, ...apiSegments].join('/');
+}
+
 function normalizeStructuredSqlType(value) {
   const normalized = String(value || '').trim();
   const upper = normalized.replace(/\s+/g, '').toUpperCase();
@@ -1023,7 +1045,7 @@ function normalizeStructuredLengthAndScale(lengthValue, scaleValue) {
   };
 }
 
-function normalizeStructuredField(inputField, index, contextLabel) {
+function normalizeStructuredField(inputField, index, contextLabel) {
   if (!inputField || typeof inputField !== 'object') {
     throw new Error(contextLabel + '[' + index + '] must be an object');
   }
@@ -1042,42 +1064,42 @@ function normalizeStructuredField(inputField, index, contextLabel) {
     throw new Error(contextLabel + '[' + index + '] is missing required field: type');
   }
 
-  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
-      : Number.parseInt(String(inputField.queryType), 10);
-  const listShow = parseBooleanLike(inputField.listShow, parseBooleanLike(inputField.show, true));
-
-  return {
-    fieldName,
-    attrName: toCamelCase(fieldName),
+  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
+      : Number.parseInt(String(inputField.queryType), 10);
+  const listShow = parseBooleanLike(inputField.listShow, parseBooleanLike(inputField.show, true));
+
+  return {
+    fieldName,
+    attrName: toCamelCase(fieldName),
     sqlType: type,
     length,
     scale,
     comment: label,
     label,
-    description: String(inputField.description || '').trim(),
-    formType: explicitFormType,
-    dictType: normalizeDictType(inputField.dictType),
-    notNull: parseBooleanLike(inputField.required, false),
-    defaultValue: normalizeDefaultValue(inputField.defaultValue),
-    readonly: parseBooleanLike(inputField.readonly, false),
-    show: parseBooleanLike(inputField.show, true),
-    listShow,
-    smart: parseBooleanLike(inputField.smart, false),
-    queryType: Number.isNaN(explicitQueryType)
-      ? undefined
-      : explicitQueryType !== undefined
-        ? explicitQueryType
-        : normalizeDictType(inputField.dictType) && listShow
-          ? 30
-          : undefined,
-    sourceKind: normalizeStructuredSourceKind(inputField.sourceKind),
-    primary: parseBooleanLike(inputField.primary, fieldName === 'id'),
-  };
-}
+    description: String(inputField.description || '').trim(),
+    formType: explicitFormType,
+    dictType: normalizeDictType(inputField.dictType),
+    notNull: parseBooleanLike(inputField.required, false),
+    defaultValue: normalizeDefaultValue(inputField.defaultValue),
+    readonly: parseBooleanLike(inputField.readonly, false),
+    show: parseBooleanLike(inputField.show, true),
+    listShow,
+    smart: parseBooleanLike(inputField.smart, false),
+    queryType: Number.isNaN(explicitQueryType)
+      ? undefined
+      : explicitQueryType !== undefined
+        ? explicitQueryType
+        : normalizeDictType(inputField.dictType) && listShow
+          ? 30
+          : undefined,
+    sourceKind: normalizeStructuredSourceKind(inputField.sourceKind),
+    primary: parseBooleanLike(inputField.primary, fieldName === 'id'),
+  };
+}
 
 function normalizeStructuredFieldArray(inputFields, contextLabel) {
   if (!Array.isArray(inputFields) || !inputFields.length) {
@@ -1114,14 +1136,14 @@ function buildRetryArguments(safeArgs) {
     tableName: safeArgs.tableName,
     ...(safeArgs.tableComment ? { tableComment: safeArgs.tableComment } : {}),
     style: safeArgs.style,
-    frontendPath: safeArgs.frontendPath,
-    moduleName: safeArgs.moduleName,
-    writeToDisk: safeArgs.writeToDisk,
-    overwrite: safeArgs.overwrite,
-    writeSupportFiles: safeArgs.writeSupportFiles,
-    mergeI18nZh: safeArgs.mergeI18nZh,
-    fields: safeArgs.fields,
-  };
+    frontendPath: safeArgs.frontendPath,
+    moduleName: safeArgs.moduleName,
+    writeToDisk: safeArgs.writeToDisk,
+    overwrite: safeArgs.overwrite,
+    writeSupportFiles: safeArgs.writeSupportFiles,
+    mergeI18nZh: safeArgs.mergeI18nZh,
+    fields: safeArgs.fields,
+  };
 
   if (safeArgs.children && safeArgs.children.length) {
     retryArguments.children = safeArgs.children;
@@ -1244,53 +1266,53 @@ function normalizeLevelsInput(inputLevels) {
   return levels;
 }
 
-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 (['business', 'dict', 'non_standard'].includes(normalized)) return normalized;
-  throw new Error(`Unsupported pageType: ${normalized}. Allowed values are dict, business, non_standard.`);
-}
-
-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 !== 'dict') return;
-  if (style === 'single_table_jump' || style === 'master_child_jump') {
-    throw new Error(`Dict pages must use dialog-based styles. pageType=dict 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: field.formType || mapFieldType(field), isAudit: isAuditField(field.fieldName) }));
-}
+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 (['business', 'dict', 'non_standard'].includes(normalized)) return normalized;
+  throw new Error(`Unsupported pageType: ${normalized}. Allowed values are dict, business, non_standard.`);
+}
+
+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 !== 'dict') return;
+  if (style === 'single_table_jump' || style === 'master_child_jump') {
+    throw new Error(`Dict pages must use dialog-based styles. pageType=dict 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: field.formType || mapFieldType(field), isAudit: isAuditField(field.fieldName) }));
+}
 
 function ensureFieldExists(fields, fieldName, tableName, role) {
   const field = fields.find((item) => item.fieldName === fieldName);
@@ -1378,33 +1400,36 @@ function buildMultiLevelDictModel(safeArgs) {
     throw new Error('multi_level_dict requires level 1 with at least one parent module');
   }
 
-  const parentModule = parentLevel.modules[0];
-  const derivedFunctionName = toCamelCase(safeArgs.tableName || parentModule.tableName);
-  const resolvedTargets = resolveGenerationTargets({
-    moduleName: safeArgs.moduleName,
-    functionName: derivedFunctionName,
-    apiPath: safeArgs.apiPath || parentModule.apiPath,
-    targetViewDir: safeArgs.targetViewDir,
-    targetApiModule: safeArgs.targetApiModule,
-    targetI18nKey: safeArgs.targetI18nKey,
-  });
-  const allModules = builtLevels.flatMap((level) => level.modules);
-  const dictTypes = [...new Set(allModules.flatMap((module) => module.optionFields.map((field) => field.dictType).filter(Boolean)))];
-
-  return {
-    featureTitle: safeArgs.featureTitle || safeArgs.tableComment || parentModule.tableComment,
-    tableName: safeArgs.tableName,
-    tableComment: safeArgs.tableComment || parentModule.tableComment,
-    apiPath: safeArgs.apiPath || parentModule.apiPath,
-    pageType: safeArgs.pageType || 'dict',
-    className: toPascalCase(safeArgs.tableName || parentModule.tableName),
-    functionName: resolvedTargets.functionName,
-    moduleName: resolvedTargets.moduleName,
-    targetViewDir: resolvedTargets.targetViewDir,
-    targetApiModule: resolvedTargets.targetApiModule,
-    targetI18nKey: resolvedTargets.targetI18nKey,
-    frontendPath: normalizeFrontendRootPath(safeArgs.frontendPath),
-    style: safeArgs.style,
+  const parentModule = parentLevel.modules[0];
+  const derivedFunctionName = toCamelCase(safeArgs.tableName || parentModule.tableName);
+  const resolvedTargets = resolveGenerationTargets({
+    moduleName: safeArgs.moduleName,
+    functionName: derivedFunctionName,
+    apiPath: safeArgs.apiPath || parentModule.apiPath,
+    targetViewDir: safeArgs.targetViewDir,
+    targetApiModule: safeArgs.targetApiModule,
+    targetI18nKey: safeArgs.targetI18nKey,
+  });
+  const allModules = builtLevels.flatMap((level) => level.modules);
+  const dictTypes = [...new Set(allModules.flatMap((module) => module.optionFields.map((field) => field.dictType).filter(Boolean)))];
+  allModules.forEach((moduleModel) => {
+    moduleModel.moduleName = resolvedTargets.moduleName;
+  });
+
+  return {
+    featureTitle: safeArgs.featureTitle || safeArgs.tableComment || parentModule.tableComment,
+    tableName: safeArgs.tableName,
+    tableComment: safeArgs.tableComment || parentModule.tableComment,
+    apiPath: safeArgs.apiPath || parentModule.apiPath,
+    pageType: safeArgs.pageType || 'dict',
+    className: toPascalCase(safeArgs.tableName || parentModule.tableName),
+    functionName: resolvedTargets.functionName,
+    moduleName: resolvedTargets.moduleName,
+    targetViewDir: resolvedTargets.targetViewDir,
+    targetApiModule: resolvedTargets.targetApiModule,
+    targetI18nKey: resolvedTargets.targetI18nKey,
+    frontendPath: normalizeFrontendRootPath(safeArgs.frontendPath),
+    style: safeArgs.style,
     levels: builtLevels,
     modules: allModules,
     dictTypes,
@@ -1475,36 +1500,36 @@ function buildModel(safeArgs) {
   const childDictTypes = children.flatMap((child) => child.optionFields.map((field) => field.dictType).filter(Boolean));
   const dictTypes = [...new Set([...optionFields.map((field) => field.dictType).filter(Boolean), ...childDictTypes])];
 
-  const derivedFunctionName = toCamelCase(safeArgs.tableName);
-  const apiPath = safeArgs.apiPath || derivedFunctionName;
-  const resolvedTargets = resolveGenerationTargets({
-    moduleName: safeArgs.moduleName,
-    functionName: derivedFunctionName,
-    apiPath,
-    targetViewDir: safeArgs.targetViewDir,
-    targetApiModule: safeArgs.targetApiModule,
-    targetI18nKey: safeArgs.targetI18nKey,
-  });
-  return {
-    featureTitle: safeArgs.featureTitle || safeArgs.tableComment || safeArgs.tableName,
-    tableName: safeArgs.tableName,
-    tableComment: safeArgs.tableComment || safeArgs.featureTitle || safeArgs.tableName,
-    apiPath,
-    pageType: safeArgs.pageType || '',
-    className: toPascalCase(safeArgs.tableName),
-    functionName: resolvedTargets.functionName,
-    moduleName: resolvedTargets.moduleName,
-    targetViewDir: resolvedTargets.targetViewDir,
-    targetApiModule: resolvedTargets.targetApiModule,
-    targetI18nKey: resolvedTargets.targetI18nKey,
-    pk: pkField,
+  const derivedFunctionName = toCamelCase(safeArgs.tableName);
+  const apiPath = safeArgs.apiPath || derivedFunctionName;
+  const resolvedTargets = resolveGenerationTargets({
+    moduleName: safeArgs.moduleName,
+    functionName: derivedFunctionName,
+    apiPath,
+    targetViewDir: safeArgs.targetViewDir,
+    targetApiModule: safeArgs.targetApiModule,
+    targetI18nKey: safeArgs.targetI18nKey,
+  });
+  return {
+    featureTitle: safeArgs.featureTitle || safeArgs.tableComment || safeArgs.tableName,
+    tableName: safeArgs.tableName,
+    tableComment: safeArgs.tableComment || safeArgs.featureTitle || safeArgs.tableName,
+    apiPath,
+    pageType: safeArgs.pageType || '',
+    className: toPascalCase(safeArgs.tableName),
+    functionName: resolvedTargets.functionName,
+    moduleName: resolvedTargets.moduleName,
+    targetViewDir: resolvedTargets.targetViewDir,
+    targetApiModule: resolvedTargets.targetApiModule,
+    targetI18nKey: resolvedTargets.targetI18nKey,
+    pk: pkField,
     fields,
     optionFields,
     visibleFields,
     listFields,
     gridFields,
     dictTypes,
-    frontendPath: normalizeFrontendRootPath(safeArgs.frontendPath),
+    frontendPath: normalizeFrontendRootPath(safeArgs.frontendPath),
     style: safeArgs.style,
     children,
   };
@@ -1648,6 +1673,8 @@ function renderFormRulesV2(fields) {
 function renderFormDefaults(model) {
   const lines = [`  ${model.pk.attrName}: '',`];
   for (const field of model.fields.filter((item) => item.fieldName !== model.pk.fieldName && !item.isAudit)) lines.push(renderDefaultLine(field));
+  lines.push(`  version: 1,`);
+  lines.push(`  tenantId: Local.getTenant(),`);
   return lines.join('\n');
 }
 
@@ -1763,27 +1790,27 @@ function getDefaultOptionFieldWidthV2(field) {
 
   return '100';
 }
-function renderOptionFieldV2(field, labelKey, dictRegistryRefs, indent = '    ') {
-  const fallbackLabel = stripDictAnnotation(field.comment).replace(/'/g, "\\'");
-  const parts = [`key: '${field.attrName}'`, `labelKey: '${labelKey}'`, `label: '${fallbackLabel}'`];
-  const width = getDefaultOptionFieldWidthV2(field);
+function renderOptionFieldV2(field, labelKey, dictRegistryRefs, indent = '    ') {
+  const fallbackLabel = stripDictAnnotation(field.comment).replace(/'/g, "\\'");
+  const parts = [`key: '${field.attrName}'`, `labelKey: '${labelKey}'`, `label: '${fallbackLabel}'`];
+  const width = getDefaultOptionFieldWidthV2(field);
 
   if (width !== '120') {
     parts.push(`width: '${width}'`);
   }
-
-  if (field.dictType) {
-    parts.push(`dictType: ${getDictRegistryReference(field.dictType, dictRegistryRefs)}`);
-  }
-  if (field.smart) {
-    parts.push('smart: true');
-  }
-  if (typeof field.queryType === 'number') {
-    parts.push(`queryType: ${field.queryType}`);
-  }
-  if (field.show === false) {
-    parts.push('show: false');
-  }
+
+  if (field.dictType) {
+    parts.push(`dictType: ${getDictRegistryReference(field.dictType, dictRegistryRefs)}`);
+  }
+  if (field.smart) {
+    parts.push('smart: true');
+  }
+  if (typeof field.queryType === 'number') {
+    parts.push(`queryType: ${field.queryType}`);
+  }
+  if (field.show === false) {
+    parts.push('show: false');
+  }
   if (field.listShow === false) {
     parts.push('listShow: false');
   }
@@ -1904,28 +1931,31 @@ function renderMultiLevelOptionField(field, model, moduleModel, dictRegistryRefs
     `labelKey: '${buildMultiLevelFieldLabelKey(model, moduleModel, field)}'`,
   ];
   const width = getDefaultOptionFieldWidthV2(field);
-  if (width) parts.push(`width: '${width}'`);
-  if (field.show === false) parts.push('show: false');
-  if (field.listShow === false) parts.push('listShow: false');
-  if (field.smart) parts.push('smart: true');
-  if (typeof field.queryType === 'number') parts.push(`queryType: ${field.queryType}`);
-  if (field.dictType) parts.push(`dictType: ${getDictRegistryReference(field.dictType, dictRegistryRefs)}`);
-  return `${indent}{ ${parts.join(', ')} },`;
-}
+  if (width) parts.push(`width: '${width}'`);
+  if (field.show === false) parts.push('show: false');
+  if (field.listShow === false) parts.push('listShow: false');
+  if (field.smart) parts.push('smart: true');
+  if (typeof field.queryType === 'number') parts.push(`queryType: ${field.queryType}`);
+  if (field.dictType) parts.push(`dictType: ${getDictRegistryReference(field.dictType, dictRegistryRefs)}`);
+  return `${indent}{ ${parts.join(', ')} },`;
+}
 
 function renderMultiLevelModuleDefinition(model, moduleModel, dictRegistryRefs) {
+  const moduleApiPath = buildApiRoutePath(model.moduleName, moduleModel.apiPath);
+  const moduleEnableApi = buildApiRoutePath(model.moduleName, moduleModel.enableApi);
+  const moduleDisableApi = buildApiRoutePath(model.moduleName, moduleModel.disableApi);
   const lines = [
-    `  ${moduleModel.key}: {`,
-    `    key: '${moduleModel.key}',`,
-    `    titleKey: '${buildMultiLevelModuleTitleKey(model, moduleModel)}',`,
-    `    apiPath: '${moduleModel.apiPath}',`,
-    `    primaryKey: '${moduleModel.pk.attrName}',`,
-  ];
+      `  ${moduleModel.key}: {`,
+      `    key: '${moduleModel.key}',`,
+      `    titleKey: '${buildMultiLevelModuleTitleKey(model, moduleModel)}',`,
+      `    apiPath: '${moduleApiPath}',`,
+      `    primaryKey: '${moduleModel.pk.attrName}',`,
+    ];
   if (moduleModel.queryParentField) lines.push(`    queryParentField: '${moduleModel.queryParentField}',`);
   if (moduleModel.statusField) lines.push(`    statusField: '${moduleModel.statusField}',`);
   if (moduleModel.statusDictType) lines.push(`    statusDictType: ${getDictRegistryReference(moduleModel.statusDictType, dictRegistryRefs)},`);
-  lines.push(`    enableApi: '${moduleModel.enableApi.startsWith('/') ? moduleModel.enableApi : '/' + moduleModel.enableApi}',`);
-  lines.push(`    disableApi: '${moduleModel.disableApi.startsWith('/') ? moduleModel.disableApi : '/' + moduleModel.disableApi}',`);
+  lines.push(`    enableApi: '${moduleEnableApi}',`);
+  lines.push(`    disableApi: '${moduleDisableApi}',`);
   lines.push('    fields: [');
   lines.push(moduleModel.optionFields.map((field) => renderMultiLevelOptionField(field, model, moduleModel, dictRegistryRefs)).join('\n'));
   lines.push('    ],');
@@ -1989,9 +2019,9 @@ function renderMultiLevelOptionsTs(model, dictRegistryRefs) {
 
 function renderMultiLevelApiFunctions(moduleModel) {
   const pkAttr = moduleModel.pk.attrName;
-  const basePath = moduleModel.apiPath.startsWith('/') ? moduleModel.apiPath : '/' + moduleModel.apiPath;
-  const enablePath = moduleModel.enableApi.startsWith('/') ? moduleModel.enableApi : '/' + moduleModel.enableApi;
-  const disablePath = moduleModel.disableApi.startsWith('/') ? moduleModel.disableApi : '/' + moduleModel.disableApi;
+  const basePath = buildApiRoutePath(moduleModel.moduleName, moduleModel.apiPath);
+  const enablePath = buildApiRoutePath(moduleModel.moduleName, moduleModel.enableApi);
+  const disablePath = buildApiRoutePath(moduleModel.moduleName, moduleModel.disableApi);
   return [
     `export function fetch${moduleModel.className}List(query?: any) {`,
     '  return request({',
@@ -2052,13 +2082,13 @@ function renderMultiLevelApiFunctions(moduleModel) {
 }
 
 function renderMultiLevelApiTs(model) {
-  return [
-    "import request from '/@/utils/request';",
-    '',
-    model.modules.map(renderMultiLevelApiFunctions).join('\n\n'),
-    '',
-  ].join('\n');
-}
+    return [
+      "import request from '/@/utils/request';",
+      '',
+      model.modules.map(renderMultiLevelApiFunctions).join('\n\n'),
+      '',
+    ].join('\n');
+  }
 
 function renderMultiLevelFormField(field) {
   const labelExpr = `getFieldLabel('${field.attrName}')`;
@@ -2143,6 +2173,8 @@ function renderMultiLevelFormVue(model, moduleModel) {
   const defaultLines = [
     `  ${moduleModel.pk.attrName}: '',`,
     ...moduleModel.optionFields.map((field) => renderDefaultLine(field)),
+    `  version: 1,`,
+    `  tenantId: Local.getTenant(),`,
   ].join('\n');
   const rules = renderFormRulesV2(moduleModel.visibleFields);
   return `<template>
@@ -2163,6 +2195,7 @@ ${moduleModel.visibleFields.map(renderMultiLevelFormField).join('\n')}
 
 <script setup lang="ts" name="${componentName}">
 import { useMessage } from '/@/hooks/message';
+import { Local } from '/@/utils/storage';
 import { useDict } from '/@/hooks/dict';
 import { useCrudPageMeta } from '/@/hooks/useCrudPageMeta';
 import { useI18n } from 'vue-i18n';
@@ -2551,15 +2584,15 @@ function renderMultiLevelMenuSql(model) {
   ].join('\n');
 }
 
-function renderMultiLevelFiles(model, sharedSupport, localeZhSupport) {
-  const dictRegistryRefs = sharedSupport.dictRegistry.keyByValue;
-  const viewRoot = buildViewRoot(model);
-  const apiFilePath = buildApiFilePath(model);
-  const menuRoot = path.join(model.frontendPath, 'menu');
-  const files = [
-    { type: 'list', path: path.join(viewRoot, 'index.vue'), content: renderMultiLevelIndexVue(model) },
-    { type: 'options', path: path.join(viewRoot, 'options.ts'), content: renderMultiLevelOptionsTs(model, dictRegistryRefs) },
-    { type: 'api', path: apiFilePath, content: renderMultiLevelApiTs(model) },
+function renderMultiLevelFiles(model, sharedSupport, localeZhSupport) {
+  const dictRegistryRefs = sharedSupport.dictRegistry.keyByValue;
+  const viewRoot = buildViewRoot(model);
+  const apiFilePath = buildApiFilePath(model);
+  const menuRoot = path.join(model.frontendPath, 'menu');
+  const files = [
+    { type: 'list', path: path.join(viewRoot, 'index.vue'), content: renderMultiLevelIndexVue(model) },
+    { type: 'options', path: path.join(viewRoot, 'options.ts'), content: renderMultiLevelOptionsTs(model, dictRegistryRefs) },
+    { type: 'api', path: apiFilePath, content: renderMultiLevelApiTs(model) },
     {
       type: 'i18nZh',
       path: localeZhSupport.path,
@@ -2583,7 +2616,8 @@ function renderMultiLevelFiles(model, sharedSupport, localeZhSupport) {
 
 function buildReplacements(model, sharedSupport) {
   const menuBaseId = Date.now();
-  const apiModulePath = model.apiPath || `${model.moduleName}/${model.functionName}`;
+  const apiModulePath = model.targetApiModule || `${model.moduleName}/${model.functionName}`;
+  const apiRoutePath = buildApiRoutePath(model.moduleName, model.apiPath || model.functionName).replace(/^\/+/, '');
   const routePath = `${model.moduleName}/${model.functionName}`;
   const permissionPrefix = `${model.moduleName}/${model.functionName}`.replace(/\//g, '_');
   const dictRegistryRefs = sharedSupport.dictRegistry.keyByValue;
@@ -2597,7 +2631,7 @@ function buildReplacements(model, sharedSupport) {
     FUNCTION_NAME: model.functionName,
     PK_ATTR: model.pk.attrName,
     API_MODULE_PATH: apiModulePath,
-    API_PATH: apiModulePath,
+    API_PATH: apiRoutePath,
     VIEW_MODULE_PATH: routePath,
     MENU_ROUTE_PATH: routePath,
     I18N_NAMESPACE: i18nNamespace,
@@ -2610,7 +2644,7 @@ function buildReplacements(model, sharedSupport) {
       MENU_BASE_ID_PLUS_5: menuBaseId + 5,
       GENERATED_AT: new Date().toISOString(),
       FORM_FIELDS: model.visibleFields.map(renderFormFieldV2).join('\n'),
-      TABLE_COLUMNS: model.gridFields.map((field) => renderTableColumn(field, dictRegistryRefs)).join('\n'),
+      TABLE_COLUMNS: model.gridFields.map((field) => renderTableColumn(field, dictRegistryRefs)).join('\n'),
       FORM_DEFAULTS: renderFormDefaults(model),
       DICT_REGISTRY_IMPORT_BLOCK: model.dictTypes.length ? "import { DictRegistry } from '/@/enums/dict-registry';" : '',
       MASTER_OPTION_FIELDS: model.optionFields.map((field) => renderOptionFieldV2(field, buildFieldLabelKey(model, field), dictRegistryRefs)).join('\n'),
@@ -2619,7 +2653,7 @@ function buildReplacements(model, sharedSupport) {
       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'),
+      CHILD_SECTIONS: model.children.map((childModel) => renderChildSection(childModel, model.children.length)).join('\n'),
     };
   }
 
@@ -2638,15 +2672,15 @@ function renderFiles(model, stylePreset, sharedSupport, localeZhSupport) {
   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 = buildViewRoot(model);
-  const apiFilePath = buildApiFilePath(model);
-  const menuRoot = path.join(model.frontendPath, 'menu');
+  const viewRoot = buildViewRoot(model);
+  const apiFilePath = buildApiFilePath(model);
+  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: apiFilePath, content: renderTemplate(apiTemplate, replacements) },
+    { type: 'api', path: apiFilePath, content: renderTemplate(apiTemplate, replacements) },
     {
       type: 'i18nZh',
       path: localeZhSupport.path,
@@ -2662,18 +2696,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');
-  rejectSemanticStageInputs(input);
-  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);
-  const pageType = normalizePageTypeInput(input.pageType);
-  getStylePreset(style);
-  validatePageTypeAndStyle(pageType, 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) : [];
 
@@ -2685,27 +2719,27 @@ function ensureArguments(input) {
     throw new Error('fields must be a non-empty array');
   }
 
-  return {
-    featureTitle: input.featureTitle ? String(input.featureTitle) : '',
-    tableName: String(input.tableName),
-    tableComment: input.tableComment ? String(input.tableComment) : '',
-    apiPath: normalizeApiPath(input.apiPath),
-    pageType,
-    style,
+  return {
+    featureTitle: input.featureTitle ? String(input.featureTitle) : '',
+    tableName: String(input.tableName),
+    tableComment: input.tableComment ? String(input.tableComment) : '',
+    apiPath: normalizeApiPath(input.apiPath),
+    pageType,
+    style,
     fields,
     levels,
-    children: normalizeChildrenInput(input.children),
-    frontendPath: String(input.frontendPath),
-    moduleName: input.moduleName ? String(input.moduleName) : 'admin/test',
-    targetViewDir: input.targetViewDir ? String(input.targetViewDir) : '',
-    targetApiModule: input.targetApiModule ? String(input.targetApiModule) : '',
-    targetI18nKey: input.targetI18nKey ? String(input.targetI18nKey) : '',
-    writeToDisk: input.writeToDisk === undefined ? true : Boolean(input.writeToDisk),
-    overwrite: input.overwrite === undefined ? true : Boolean(input.overwrite),
-    writeSupportFiles: input.writeSupportFiles === undefined ? true : Boolean(input.writeSupportFiles),
-    mergeI18nZh: input.mergeI18nZh === undefined ? true : Boolean(input.mergeI18nZh),
-  };
-}
+    children: normalizeChildrenInput(input.children),
+    frontendPath: String(input.frontendPath),
+    moduleName: input.moduleName ? String(input.moduleName) : 'admin/test',
+    targetViewDir: input.targetViewDir ? String(input.targetViewDir) : '',
+    targetApiModule: input.targetApiModule ? String(input.targetApiModule) : '',
+    targetI18nKey: input.targetI18nKey ? String(input.targetI18nKey) : '',
+    writeToDisk: input.writeToDisk === undefined ? true : Boolean(input.writeToDisk),
+    overwrite: input.overwrite === undefined ? true : Boolean(input.overwrite),
+    writeSupportFiles: input.writeSupportFiles === undefined ? true : Boolean(input.writeSupportFiles),
+    mergeI18nZh: input.mergeI18nZh === undefined ? true : Boolean(input.mergeI18nZh),
+  };
+}
 
 function maybeWriteFiles(files, writeToDisk, overwrite) {
   if (!writeToDisk) return;
@@ -2728,43 +2762,43 @@ function maybeWriteFiles(files, writeToDisk, overwrite) {
   }
 }
 
-function buildManifest(model, safeArgs, stylePreset, files, note) {
-  if (model.style === 'multi_level_dict') {
-    return {
-      mode: 'local-template',
-      style: safeArgs.style,
-      pageType: model.pageType || '',
-      styleLabel: stylePreset.label,
+function buildManifest(model, safeArgs, stylePreset, files, note) {
+  if (model.style === 'multi_level_dict') {
+    return {
+      mode: 'local-template',
+      style: safeArgs.style,
+      pageType: model.pageType || '',
+      styleLabel: stylePreset.label,
       runtimeSupported: hasRuntimeSupport(stylePreset),
-      tableName: model.tableName,
-      tableComment: model.tableComment,
-      apiPath: model.apiPath,
-      moduleName: model.moduleName,
-      targetViewDir: model.targetViewDir,
-      targetApiModule: model.targetApiModule,
-      targetI18nKey: model.targetI18nKey,
-      writeToDisk: safeArgs.writeToDisk,
-      sideEffects: {
-        writeSupportFiles: safeArgs.writeSupportFiles,
-        mergeI18nZh: safeArgs.mergeI18nZh,
-      },
-      files: files.map((file) => ({ type: file.type, path: file.path, bytes: Buffer.byteLength(file.content, 'utf8'), status: file.status || (safeArgs.writeToDisk ? 'success' : 'rendered') })),
-      levels: model.levels.map((level) => ({
-        levelIndex: level.levelIndex,
-        position: level.position,
-        modules: level.modules.map((moduleModel) => ({
-          key: moduleModel.key,
-          tableName: moduleModel.tableName,
-          tableComment: moduleModel.tableComment,
-          apiPath: moduleModel.apiPath,
-          primaryKey: moduleModel.pk.fieldName,
-          queryParentField: moduleModel.queryParentField,
-          statusField: moduleModel.statusField,
-          statusDictType: moduleModel.statusDictType,
-          enableApi: moduleModel.enableApi,
-          disableApi: moduleModel.disableApi,
+      tableName: model.tableName,
+      tableComment: model.tableComment,
+        apiPath: buildApiRoutePath(model.moduleName, model.apiPath).replace(/^\/+/, ''),
+      moduleName: model.moduleName,
+      targetViewDir: model.targetViewDir,
+      targetApiModule: model.targetApiModule,
+      targetI18nKey: model.targetI18nKey,
+      writeToDisk: safeArgs.writeToDisk,
+      sideEffects: {
+        writeSupportFiles: safeArgs.writeSupportFiles,
+        mergeI18nZh: safeArgs.mergeI18nZh,
+      },
+      files: files.map((file) => ({ type: file.type, path: file.path, bytes: Buffer.byteLength(file.content, 'utf8'), status: file.status || (safeArgs.writeToDisk ? 'success' : 'rendered') })),
+        levels: model.levels.map((level) => ({
+          levelIndex: level.levelIndex,
+          position: level.position,
+          modules: level.modules.map((moduleModel) => ({
+            key: moduleModel.key,
+            tableName: moduleModel.tableName,
+            tableComment: moduleModel.tableComment,
+              apiPath: buildApiRoutePath(model.moduleName, moduleModel.apiPath).replace(/^\/+/, ''),
+            primaryKey: moduleModel.pk.fieldName,
+            queryParentField: moduleModel.queryParentField,
+            statusField: moduleModel.statusField,
+            statusDictType: moduleModel.statusDictType,
+              enableApi: buildApiRoutePath(model.moduleName, moduleModel.enableApi).replace(/^\/+/, ''),
+              disableApi: buildApiRoutePath(model.moduleName, moduleModel.disableApi).replace(/^\/+/, ''),
+          })),
         })),
-      })),
       summary: {
         totalLevels: model.levels.length,
         totalModules: model.modules.length,
@@ -2786,36 +2820,36 @@ function buildManifest(model, safeArgs, stylePreset, files, note) {
   }));
   const selectedList = relations.map((relation) => formatRelationCandidate(relation));
 
-  return {
-    mode: 'local-template',
-    style: safeArgs.style,
-    pageType: model.pageType || '',
-    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,
-    apiPath: model.apiPath,
-    moduleName: model.moduleName,
-    targetViewDir: model.targetViewDir,
-    targetApiModule: model.targetApiModule,
-    targetI18nKey: model.targetI18nKey,
-    writeToDisk: safeArgs.writeToDisk,
-    sideEffects: {
-      writeSupportFiles: safeArgs.writeSupportFiles,
-      mergeI18nZh: safeArgs.mergeI18nZh,
-    },
-    files: files.map((file) => ({ type: file.type, path: file.path, bytes: Buffer.byteLength(file.content, 'utf8'), status: file.status || (safeArgs.writeToDisk ? 'success' : 'rendered') })),
+    tableName: model.tableName,
+    tableComment: model.tableComment,
+    apiPath: buildApiRoutePath(model.moduleName, model.apiPath).replace(/^\/+/, ''),
+    moduleName: model.moduleName,
+    targetViewDir: model.targetViewDir,
+    targetApiModule: model.targetApiModule,
+    targetI18nKey: model.targetI18nKey,
+    writeToDisk: safeArgs.writeToDisk,
+    sideEffects: {
+      writeSupportFiles: safeArgs.writeSupportFiles,
+      mergeI18nZh: safeArgs.mergeI18nZh,
+    },
+    files: files.map((file) => ({ type: file.type, path: file.path, bytes: Buffer.byteLength(file.content, 'utf8'), status: file.status || (safeArgs.writeToDisk ? 'success' : 'rendered') })),
     relation: relations.length === 1 ? relations[0] : null,
     relations,
     relationResolution: model.children.length
       ? {
           status: 'structured_input',
-          tableName: safeArgs.tableName,
-          source: 'arguments',
-          message:
-            model.children.length > 1
-              ? 'Direct child relations were provided by the caller as structured metadata. MCP generated a single main form with multiple child tables.'
-              : 'The relation was provided by the caller as structured metadata. MCP generated files directly.',
+          tableName: safeArgs.tableName,
+          source: 'arguments',
+          message:
+            model.children.length > 1
+              ? 'Direct child relations were provided by the caller as structured metadata. MCP generated a single main form with multiple child tables.'
+              : 'The relation was provided by the caller as structured metadata. MCP generated files directly.',
           selected: selectedList.length === 1 ? selectedList[0] : null,
           selectedList,
           correctionEntry: {
@@ -2851,24 +2885,24 @@ function buildManifest(model, safeArgs, stylePreset, files, note) {
   };
 }
 
-async function handleToolCall(argumentsObject) {
-  const safeArgs = ensureArguments(argumentsObject);
-  const stylePreset = getStylePreset(safeArgs.style);
-  const model = buildModel(safeArgs);
-  const sharedSupport = prepareSharedSupport(model.frontendPath, model.dictTypes, safeArgs.writeSupportFiles);
-  const localeZhSupport = prepareZhCnLocaleFile(model, safeArgs.mergeI18nZh);
-
-  if (!hasRuntimeSupport(stylePreset)) {
-    const manifest = buildManifest(model, safeArgs, stylePreset, [], '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, sharedSupport, localeZhSupport);
-  maybeWriteFiles(files, safeArgs.writeToDisk, safeArgs.overwrite);
-  maybeWriteSharedSupport(sharedSupport, safeArgs.writeToDisk);
-  const manifest = buildManifest(model, safeArgs, stylePreset, files, buildSupportNote(sharedSupport, localeZhSupport));
-  return toolTextResult(JSON.stringify(manifest, null, 2));
-}
+async function handleToolCall(argumentsObject) {
+  const safeArgs = ensureArguments(argumentsObject);
+  const stylePreset = getStylePreset(safeArgs.style);
+  const model = buildModel(safeArgs);
+  const sharedSupport = prepareSharedSupport(model.frontendPath, model.dictTypes, safeArgs.writeSupportFiles);
+  const localeZhSupport = prepareZhCnLocaleFile(model, safeArgs.mergeI18nZh);
+
+  if (!hasRuntimeSupport(stylePreset)) {
+    const manifest = buildManifest(model, safeArgs, stylePreset, [], '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, sharedSupport, localeZhSupport);
+  maybeWriteFiles(files, safeArgs.writeToDisk, safeArgs.overwrite);
+  maybeWriteSharedSupport(sharedSupport, safeArgs.writeToDisk);
+  const manifest = buildManifest(model, safeArgs, stylePreset, files, buildSupportNote(sharedSupport, localeZhSupport));
+  return toolTextResult(JSON.stringify(manifest, null, 2));
+}
 
 async function onMessage(message) {
   const { id, method, params } = message;
@@ -2894,11 +2928,11 @@ async function onMessage(message) {
       successResponse(id, {
         tools: [
           {
-            name: TOOL_NAME,
-            description:
-              'Generate Worsoft frontend files and menu SQL from structured feature metadata. In master_child_jump mode, the caller must provide children[] with explicit payloadField and child field metadata. In multi_level_dict mode, the caller must provide levels[] with explicit hierarchy metadata.',
-            inputSchema: TOOL_SCHEMA,
-          },
+            name: TOOL_NAME,
+            description:
+              'Generate Worsoft frontend files and menu SQL from structured feature metadata. In master_child_jump mode, the caller must provide children[] with explicit payloadField and child field metadata. In multi_level_dict mode, the caller must provide levels[] with explicit hierarchy metadata.',
+            inputSchema: TOOL_SCHEMA,
+          },
         ],
       })
     );