lan-low-code-cli 2.5.0 → 2.6.0

package/README.md

@@ -77,6 +77,70 @@ llc form create --name <名称> [选项]
 | `--fd-run-entity-name <name>` | 表单运行时实体名称 |
 | `--table-name <name>` | 主表名（不传则调用对应接口自动生成） |
 
+**表单类型**（`--type`）：
+
+| 类型 | 说明 | 表结构 |
+|---|---|---|
+| 缺省 / `common` | 普通表单（应用下默认走 `modeling` 族） | 主表 |
+| `category` | 分类表单：分类树 + 多个模板 | 分类表 + 模板表 + 主表 |
+| `simpleCategory` | 简单分类表单：分类与模板合一，强制多层级 | 聚合表 + 主表 |
+
+```bash
+# 分类表单：自动生成三张表名，创建后立即发布
+llc form create --name "采购分类表单" --app-id <appId> --type category --publish
+
+# 简单分类表单
+llc form create --name "简版分类表单" --app-id <appId> --type simpleCategory --publish
+
+# 共享已有分类表单的分类（沿用对方的分类表与层级设置）
+llc form create --name "共享分类表单" --app-id <appId> --type category --share-category purchaseCategory
+```
+
+- 分类表单走 `categoryModel/init → add →（--publish 时 save → publish）`，与普通表单接口完全不同；
+- 表名可用 `--table-name`（主表）、`--category-table-name`、`--template-table-name`（分类）、
+  `--polymers-table-name`（简单分类聚合表）显式指定，缺省逐个调用 `generateTableName`；
+- 分类表单本身**不含业务字段**，`--add-field` / `--fields` / `--from-model` 会被拒绝——字段属于「模板」；
+- 默认多层级分类，`--no-support-hierarchy` 改单层级；简单分类强制多层级、不支持共享分类；
+- 模板（模板表单）用下面的 `llc template create` 创建；
+- 分类表单的删除只能在平台操作（后端 `categoryModel/delete` 禁止前端直接调用），
+  `form get --id` 已能识别分类表单并展示 `fdType` / 三张表名。
+
+**分类表单模板**（`llc template`）：
+
+```bash
+# 列出分类表单下的模板（运行时分类树）
+llc template list --category-code <categoryCode>
+
+# 创建模板，并把既有表单的字段 / 视图 / 权限移植进来，然后发布
+llc template create --category-code <categoryCode> --name "合作模板" \
+  --from-form <来源表单 fdId> --publish
+
+# 给已有模板追加字段（默认重建栅格布局让新字段可见；--keep-layout 保留原布局）
+llc template add-fields --template-id <templateId> --category-code <categoryCode> \
+  --add-field "fd_budget:合作预算:moneytext" \
+  --add-field "fd_contact:对接人:address" --publish
+
+# 删除模板（--all 清空该分类表单下的模板，需 --yes）
+llc template delete --category-code <categoryCode> --all --yes
+llc template delete --category-code <categoryCode> --template-id <templateId> --yes
+```
+
+- 分类表单 `fdType=1` 走 `categoryTemplate/add`，简单分类 `fdType=2` 走 `virtualPolymers/add`；
+- **跳过官方 `init`**：模板表元数据未就绪时 `init` 会空指针，改为 `add` + `mechanisms['sys-xform'].fdBuildNew=true`
+  由后端建表并注册元数据，再 `sys-xform/sysXFormDesign/save` 写入设计；
+- `--from-form` 会克隆来源表单的主表业务字段、视图布局（页签/栅格）与字段权限，表名替换为模板表；
+  **明细表节点会被剔除**（模板表结构不支持直接挂明细），可用 `--fields` 只取部分字段；
+- 分类表单的模板必须挂在分类节点下：不传 `--category-node` 时自动建一个分类节点（名称默认取模板名，可用
+  `--category-name` 指定）；
+- 创建后 `template list` 能看到，平台发起页即可选择该模板填写。
+- 注意区分两份设计：`template add-fields` 改的是**模板实体**的表单设计（落模板表/聚合表）；
+  而简单分类表单「自身的模板表单」（前台新建模板时默认使用的那份）用
+  `llc form autofill --id <分类表单 fdId> --add-field ... --apply --publish` 维护，两者互不影响。
+- 模板编辑器打开时会拿分类表单的**发布配置**（`categoryModel/getReleaseConfig`）做字段合并，
+  该配置缺 `sign` 时会报 `Cannot read properties of undefined (reading 'formula')`；
+  `template create` 会自动检查并用分类表单自身设计重新发布补齐
+  （等价于对分类表单执行 `form autofill --id <分类表单 fdId> --apply --publish`）。
+
 其余选项：
 
 | 选项 | 说明 |
@@ -196,6 +260,55 @@ llc field library [--keyword <kw>]  # 字段库
 llc field gen-key --name <名称>      # 生成字段编码
 ```
 
+### 表单业务操作
+
+在表单的列表页/查看页上增加按钮（对应平台「表单 → 业务操作」Tab）。
+
+```bash
+llc operation list --form-id <fdId>
+llc operation create --form-id <fdId> --name 打开帮助 --code openHelp \
+  --type link --position view --url https://example.com
+llc operation create --form-id <fdId> --name 批量归档 --code archive \
+  --type script --script @archive.js
+llc operation create --form-id <fdId> --name 转办 --code transfer \
+  --type dialog --dialog-id <对话框id>
+llc operation get --id <operationId>
+llc operation update --id <operationId> --type script \
+  --script @examples/operation-script-modal-table.js   # 把已有按钮改成脚本模式
+llc operation attach --form-id <fdId> --operation-id <operationId>   # 挂到列表视图（desktop/top）
+llc operation attach --form-id <fdId> --operation-id <operationId> --target view --position rightHand
+llc operation detach --form-id <fdId> --operation-id <operationId>   # 从视图移除
+llc operation delete --id <operationId> --yes   # 被页面引用时拒绝
+```
+
+- `--type`：`link`（fdType=2 / fdViewType=4，需 `--url`）、`script`（3 / 5，需 `--script`，支持 `@文件`）、
+  `dialog`（3 / 1，需 `--dialog-id`）
+- `--position`：`list`（默认，列表视图）/ `view`（查看视图）
+- 默认不要求勾选数据；需要“先勾选数据再执行”时加 `--need-select`（链接会按接口调用，`fdUrlType=2`）
+- `--dry-run` 只打印请求体；新建操作默认仅管理员可用
+- `update` 基于现有操作合并：显式 `--type` 才切换类型（会重建类型相关配置，保留权限/默认值配置），
+  省略时保持原类型；`--script` 支持 `@文件`，配套示例见
+  `examples/operation-script-modal-table.js`（弹窗 + 表格）
+- `attach` / `detach` 修改视图的 `operationList`：列表视图写 `fdExtendConfig`，查看视图写 `fdConfig`；
+  `--view-id` 省略时自动定位该表单唯一的视图，重复挂载幂等
+
+脚本模式（fdType=3 / fdViewType=5）的脚本在页面中这样执行：
+
+```js
+new Function('context', fdJavaScript)({
+  ...context,
+  fdOprId, fdIds, fdBtnCfg, destroyLoading,
+})
+```
+
+- `context.fdIds` 仅在行内按钮/标准行操作时有值（当前行 id）；工具栏按钮的勾选在 `context.selectedId`（数组），
+  当前行 id 另有 `context.docId`
+- 弹窗能力来自宿主页面的 `window.MKXFORM`（`tableModal` / `modal` / `HTMLModal`）
+- 脚本内调用 `context.destroyLoading()` 可主动关闭「执行中...」提示
+- 完整上下文清单（选中数据、刷新列表、查询、跳转、事件总线、移动端差异）见
+  [skills/lan-low-code-cli/references/operation-script-context.md](skills/lan-low-code-cli/references/operation-script-context.md)
+
+
 ### 控件类型
 
 **先查环境再选控件**：

package/dist/api/formDefine.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataSetApi = exports.modelingAppApi = exports.modelingXFormApi = exports.designApi = exports.wordsFieldApi = exports.dataModelApi = exports.formCategoryApi = exports.formDefineApi = void 0;
+exports.dataSetApi = exports.modelingAppApi = exports.categoryModelApi = exports.modelingXFormApi = exports.designApi = exports.wordsFieldApi = exports.dataModelApi = exports.formCategoryApi = exports.formDefineApi = void 0;
 /**
  * 表单定义接口（后端 SysGeneralFormDefineController）
  * 基础路径：/data/sys-xform/generalFormDefine/
@@ -141,6 +141,36 @@ exports.modelingXFormApi = {
     /** 删除业务表单的运行时数据（保留表单定义） */
     removeData: (client, fdId) => client.post(`${MODELING_XFORM_BASE}/deleteData`, { fdId }),
 };
+/**
+ * 分类表单 / 简单分类表单（后端 SysModelingCategoryModelController）
+ *
+ * 基础路径：/data/sys-modeling/categoryModel/
+ * 流程：init（预生成 fdId 与机制）→ add（建档并建主表）→ save/publish（发布态）
+ *
+ * fdType：1=分类表单（分类表 + 模板表 + 主表）、2=简单分类表单（聚合表 + 主表）
+ */
+const CATEGORY_MODEL_BASE = 'sys-modeling/categoryModel';
+exports.categoryModelApi = {
+    /** 初始化：返回预生成 fdId 与机制（sys-xform 等） */
+    init: (client) => client.post(`${CATEGORY_MODEL_BASE}/init`, {}),
+    /** 新建分类表单，返回 { fdId } */
+    add: (client, payload) => client.post(`${CATEGORY_MODEL_BASE}/add`, payload),
+    /** 详情（含 mechanisms） */
+    get: (client, fdId) => client.post(`${CATEGORY_MODEL_BASE}/get`, {
+        fdId,
+        mechanisms: { load: '*' },
+    }),
+    /** 保存（草稿） */
+    save: (client, payload) => client.post(`${CATEGORY_MODEL_BASE}/save`, payload),
+    /** 发布 */
+    publish: (client, payload) => client.post(`${CATEGORY_MODEL_BASE}/publish`, payload),
+    /** 列表（按编码/名称等条件查询） */
+    list: (client, request = {}) => client.post(`${CATEGORY_MODEL_BASE}/list`, {
+        pageNo: 1,
+        pageSize: 20,
+        ...request,
+    }),
+};
 /** 业务建模应用接口 */
 const MODELING_APP_BASE = 'sys-modeling/sysModelingApplication';
 exports.modelingAppApi = {

package/dist/api/operation.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationApi = void 0;
+/**
+ * 表单业务操作接口（后端 SysModelingOperationController）
+ * 基础路径：/data/sys-modeling/sysModelingOperation/
+ * 所有接口均为 POST + JSON
+ */
+const BASE = 'sys-modeling/sysModelingOperation';
+exports.operationApi = {
+    /** 业务操作列表（按表单：conditions.fdXForm） */
+    list: (client, request = {}) => client.post(`${BASE}/list`, request),
+    /** 业务操作详情 */
+    get: (client, fdId) => client.post(`${BASE}/get`, { fdId }),
+    /** 新建业务操作，返回 { fdId } */
+    add: (client, vo) => client.post(`${BASE}/add`, vo),
+    /** 修改业务操作（请求体为完整 VO，未提交的字段会被保留） */
+    update: (client, vo) => client.post(`${BASE}/update`, vo),
+    /** 删除业务操作 */
+    remove: (client, fdId) => client.post(`${BASE}/delete`, { fdId }),
+    /** 查询业务操作被引用的情况（删除前校验） */
+    listByRefer: (client, fdId) => client.post(`${BASE}/listByRefer`, {
+        conditions: { fdReferId: fdId },
+        offset: 0,
+        pageSize: 1000,
+    }),
+};

package/dist/api/template.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateApi = void 0;
+/**
+ * 分类表单模板（发起页模板）接口。
+ *
+ * 模板不是普通表单：分类表单下挂的是「虚拟模板」
+ *   - 分类表单（fdType=1）：`/data/sys-modeling/categoryTemplate/*`
+ *   - 简单分类表单（fdType=2）：`/data/sys-modeling/virtualPolymers/*`
+ * 两者都可通过 `virtualCommonTemplate/*` 统一 get / save / publish。
+ *
+ * 注意：官方 `init` 接口在模板表元数据未就绪时会空指针（FormTemplateVirtualMetaEntityListener），
+ * 因此这里直接 `add`（带 `mechanisms['sys-xform'].fdBuildNew=true`），由后端建表并生成元数据，
+ * 再用 `sys-xform/sysXFormDesign/save` 写入字段与视图。
+ */
+const CATEGORY_MODEL_BASE = 'sys-modeling/categoryModel';
+const CATEGORY_TEMPLATE_BASE = 'sys-modeling/categoryTemplate';
+const POLYMERS_BASE = 'sys-modeling/virtualPolymers';
+const VIRTUAL_COMMON_BASE = 'sys-modeling/virtualCommonTemplate';
+const VIRTUAL_CATEGORY_BASE = 'sys-modeling/virtualCategory';
+exports.templateApi = {
+    /** 按编码查分类表单（分类表单与简单分类表单都在 categoryModel 表） */
+    findCategoryByCode: (client, code) => client.post(`${CATEGORY_MODEL_BASE}/list`, {
+        conditions: { fdCode: code },
+        pageNo: 1,
+        pageSize: 1,
+        count: true,
+    }),
+    /** 创建模板：简单分类走 virtualPolymers，普通分类走 categoryTemplate */
+    create: (client, kind, payload) => client.post(kind === 'simple' ? `${POLYMERS_BASE}/add` : `${CATEGORY_TEMPLATE_BASE}/add`, payload),
+    /** 读取模板（统一入口，按分类表单类型分流） */
+    get: (client, fdId, categoryCode) => client.post(`${VIRTUAL_COMMON_BASE}/get`, {
+        fdId,
+        fdCategoryModelCode: categoryCode,
+        mechanisms: { load: '*' },
+    }),
+    /** 保存模板 */
+    save: (client, payload) => client.post(`${VIRTUAL_COMMON_BASE}/save`, payload),
+    /** 发布模板 */
+    publish: (client, payload) => client.post(`${VIRTUAL_COMMON_BASE}/publish`, payload),
+    /** 更新模板（用于挂分类节点等） */
+    update: (client, payload) => client.post(`${VIRTUAL_COMMON_BASE}/update`, payload),
+    /** 模板列表（运行时分类树，含模板卡片） */
+    tree: (client, categoryCode) => client.post(`${VIRTUAL_CATEGORY_BASE}/tree`, { fdCategoryModelCode: categoryCode, mechanisms: { load: '*' } }),
+    /** 新建分类节点（分类表单的模板必须挂在分类节点下才会出现在发起页） */
+    addCategoryNode: (client, payload) => client.post(`${VIRTUAL_CATEGORY_BASE}/add`, {
+        hasChild: false,
+        ...payload,
+    }),
+    /** 列出分类表单下的模板：简单分类走运行时树，分类表单走 listAll */
+    listByCategory: (client, kind, categoryCode) => kind === 'simple'
+        ? client.post(`${VIRTUAL_CATEGORY_BASE}/tree`, { fdCategoryModelCode: categoryCode, mechanisms: { load: '*' } })
+        : client.post(`${CATEGORY_TEMPLATE_BASE}/listAll`, {
+            fdCategoryModelCode: categoryCode,
+            mechanisms: { load: '*' },
+        }),
+    /** 批量删除模板 */
+    deleteTemplates: (client, kind, categoryCode, fdIds) => kind === 'simple'
+        ? client.post(`${POLYMERS_BASE}/batchDelete`, {
+            fdIds,
+            fdCategoryModelCode: categoryCode,
+        })
+        : client.post(`${CATEGORY_TEMPLATE_BASE}/batchDelete`, {
+            fdIds,
+            fdCategoryModelCode: categoryCode,
+        }),
+    /** 删除分类节点 */
+    deleteCategoryNode: (client, categoryCode, fdId) => client.post(`${VIRTUAL_CATEGORY_BASE}/delete`, {
+        fdId,
+        fdCategoryModelCode: categoryCode,
+    }),
+    /** 读取模板的表单设计（xform 设计器接口） */
+    loadDesign: (client, fdId) => client.post(`sys-xform/sysXFormDesign/load`, { fdId }),
+    /** 保存模板的表单设计 */
+    saveDesign: (client, payload) => client.post(`sys-xform/sysXFormDesign/save`, payload),
+};

package/dist/api/view.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formViewApi = exports.listViewApi = void 0;
+/** 列表视图：按钮配置在 fdExtendConfig[platform].operationList */
+const LIST_VIEW_BASE = 'sys-modeling/sysModelingListView';
+/** 查看/新建视图：按钮配置在 fdConfig[platform].operationList */
+const VIEW_BASE = 'sys-modeling/sysModelingView';
+exports.listViewApi = {
+    list: (client, request = {}) => client.post(`${LIST_VIEW_BASE}/list`, request),
+    get: (client, fdId) => client.post(`${LIST_VIEW_BASE}/get`, {
+        fdId,
+        mechanisms: { load: '*' },
+    }),
+    update: (client, vo) => client.post(`${LIST_VIEW_BASE}/update`, vo),
+};
+exports.formViewApi = {
+    list: (client, request = {}) => client.post(`${VIEW_BASE}/list`, request),
+    get: (client, fdId) => client.post(`${VIEW_BASE}/get`, {
+        fdId,
+        mechanisms: { load: '*' },
+    }),
+    update: (client, vo) => client.post(`${VIEW_BASE}/update`, vo),
+};

package/dist/commands/form.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectNewFields = injectNewFields;
 exports.registerFormCommand = registerFormCommand;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -674,6 +675,155 @@ async function loadModels(client, formId, fromModel) {
     }
     return (await formDefine_1.dataModelApi.loadByFormId(client, formId)) ?? [];
 }
+/** 分类表单默认图标（与平台分类表单弹窗一致） */
+const CATEGORY_FORM_ICON = {
+    category: '{"name":"iconCommon_line_16_classificationTemplateModel","type":"vector","style":{"backgroundColor":"","color":"#F6940A","borderRadius":0,"fontSize":""},"normalize":true}',
+    simpleCategory: '{"name":"iconCommon_line_16_simpleClassificationModel","type":"vector","style":{"backgroundColor":"","color":"#5D4DD5","borderRadius":0,"fontSize":""},"normalize":true}',
+};
+function normalizeCategoryType(raw) {
+    if (!raw)
+        return undefined;
+    const key = raw.trim().toLowerCase().replace(/[-_\s]/g, '');
+    if (key === 'category' || key === 'categoryform')
+        return 'category';
+    if (key === 'simplecategory' || key === 'simplecategoryform')
+        return 'simpleCategory';
+    return undefined;
+}
+/**
+ * 构造分类表单的 mechanisms：init 返回的每个机制补上 fdName / fdTableName（主表名），
+ * 与前端 categoryModal 的 mergeData 保持一致。
+ */
+function buildCategoryMechanisms(source, fdName, fdTableName) {
+    const result = {};
+    Object.keys(source ?? {}).forEach((key) => {
+        const value = source?.[key];
+        result[key] = {
+            ...(value && typeof value === 'object' ? value : {}),
+            fdName,
+            fdTableName,
+        };
+    });
+    return result;
+}
+/**
+ * 创建分类表单 / 简单分类表单：categoryModel/init → add →（--publish 时 save + publish）。
+ *
+ * 注意：分类表单本身不含业务字段，字段属于「模板（模板表单）」；
+ * 模板表元数据由平台设计器首次保存时生成，CLI 侧 template 创建需在该操作之后。
+ */
+async function createCategoryForm(client, opts, type) {
+    const appId = String(opts.appId ?? '').trim();
+    if (!appId)
+        throw new Error('分类表单（--type category|simpleCategory）必须提供 --app-id');
+    if (opts.addField?.length || opts.fields || opts.fromModel) {
+        throw new Error('分类表单本身没有业务字段，不支持 --add-field / --fields / --from-model；字段请在模板（模板表单）中配置');
+    }
+    const name = String(opts.name ?? '').trim();
+    if (!name)
+        throw new Error('--name 不能为空');
+    if (name.length > 20)
+        throw new Error('分类表单名称最长 20 个字符');
+    const app = await formDefine_1.modelingAppApi.get(client, appId);
+    const appCode = String(app.fdAppCode ?? '').trim();
+    if (!appCode)
+        throw new Error(`未能读取应用编码（appId=${appId}）`);
+    logger_1.logger.step('初始化分类表单（categoryModel/init）');
+    const init = await formDefine_1.categoryModelApi.init(client);
+    if (!init?.fdId)
+        throw new Error('categoryModel/init 未返回 fdId');
+    const takeTableName = async (given, label) => {
+        const explicit = String(given ?? '').trim();
+        if (explicit)
+            return explicit;
+        logger_1.logger.step(`生成${label}（sysModelingXForm/generateTableName）`);
+        return formDefine_1.modelingXFormApi.generateTableName(client);
+    };
+    const isSimple = type === 'simpleCategory';
+    const fdType = isSimple ? 2 : 1;
+    const fdMainTableName = await takeTableName(opts.tableName, '主表名');
+    let fdCategoryTableName = '';
+    let fdTemplateTableName = '';
+    let fdPolymersTableName = '';
+    let fdSupportHierarchy = opts.supportHierarchy !== false;
+    if (isSimple) {
+        fdPolymersTableName = await takeTableName(opts.polymersTableName, '聚合表名');
+        // 简单分类表单固定多层级
+        fdSupportHierarchy = true;
+    }
+    else {
+        fdCategoryTableName = await takeTableName(opts.categoryTableName, '分类表名');
+        fdTemplateTableName = await takeTableName(opts.templateTableName, '模板表名');
+    }
+    // 共享已有分类：沿用对方的分类表与层级配置
+    const shareCategory = String(opts.shareCategory ?? '').trim();
+    if (shareCategory) {
+        if (isSimple)
+            throw new Error('简单分类表单不支持共享已有分类');
+        const shared = await formDefine_1.categoryModelApi.list(client, {
+            conditions: { fdCode: shareCategory, fdType: { $eq: 1 } },
+            pageSize: 1,
+        });
+        const target = shared?.content?.[0];
+        if (!target?.fdCategoryTableName)
+            throw new Error(`未找到可共享的分类表单：${shareCategory}`);
+        fdCategoryTableName = String(target.fdCategoryTableName);
+        fdSupportHierarchy = Boolean(target.fdSupportHierarchy);
+    }
+    const payload = stripUndefined({
+        fdId: init.fdId,
+        fdType,
+        fdAppId: appId,
+        fdAppCode: appCode,
+        fdName: name,
+        fdCode: String(opts.code ?? '').trim() || `category_${Date.now().toString(36).slice(-6)}`,
+        fdIcon: opts.icon ? (0, icon_1.normalizeIcon)(opts.icon) : CATEGORY_FORM_ICON[type],
+        fdShareCategory: Boolean(shareCategory),
+        fdSupportHierarchy,
+        fdCategoryTableName: fdCategoryTableName || undefined,
+        fdTemplateTableName: fdTemplateTableName || undefined,
+        fdPolymersTableName: fdPolymersTableName || undefined,
+        fdMainTableName,
+        mechanisms: buildCategoryMechanisms(init.mechanisms, name, fdMainTableName),
+    });
+    logger_1.logger.info(logger_1.color.gray(`类型：${isSimple ? '简单分类表单' : '分类表单'}　应用：${appCode}　主表：${fdMainTableName}　` +
+        (isSimple
+            ? `聚合表：${fdPolymersTableName}`
+            : `分类表：${fdCategoryTableName}　模板表：${fdTemplateTableName}`)));
+    if (opts.dryRun) {
+        logger_1.logger.title('【dry-run】将提交（categoryModel/add）');
+        logger_1.logger.json(payload);
+        return;
+    }
+    logger_1.logger.step(`创建分类表单：${name}`);
+    const created = await formDefine_1.categoryModelApi.add(client, payload);
+    const fdId = created?.fdId ?? init.fdId;
+    logger_1.logger.success(`分类表单创建成功，fdId = ${fdId}`);
+    if (opts.publish) {
+        logger_1.logger.step('发布分类表单（categoryModel/save → publish）');
+        const detail = await formDefine_1.categoryModelApi.get(client, fdId);
+        const fdConfig = detail.fdConfig ?? JSON.stringify({ PC: {}, mobile: {} });
+        await formDefine_1.categoryModelApi.save(client, { ...detail, fdConfig });
+        await formDefine_1.categoryModelApi.publish(client, { ...detail, fdConfig, fdStatus: 'official' });
+        logger_1.logger.success('分类表单已发布');
+    }
+    if (opts.json) {
+        logger_1.logger.json({
+            fdId,
+            type,
+            fdType,
+            tables: {
+                main: fdMainTableName,
+                category: fdCategoryTableName || undefined,
+                template: fdTemplateTableName || undefined,
+                polymers: fdPolymersTableName || undefined,
+            },
+        });
+        return;
+    }
+    logger_1.logger.info(logger_1.color.gray('提示：分类表单的模板（模板表单）需在平台「发起页设计器」中创建；' +
+        '模板表元数据由设计器首次保存时生成，CLI 直接调用 categoryTemplate/init 会报空指针。'));
+}
 function registerFormCommand(program) {
     const form = program.command('form').description('表单相关操作（创建 / 查询 / 发布 / 自动完善字段）');
     // ------------------------------------------------------------------ create
@@ -682,13 +832,20 @@ function registerFormCommand(program) {
         .description('创建表单，并（可选）根据数据模型自动完善字段配置')
         .requiredOption('--name <name>', '表单名称')
         .option('--code <code>', '表单业务编码，默认自动生成')
-        .option('--type <type>', '表单类型：common|general|config|modal|template|refer。缺省时 general 族用 general、其余用 common')
+        .option('--type <type>', '表单类型：common|general|config|modal|template|refer，' +
+        '或 category（分类表单）| simpleCategory（简单分类表单）。' +
+        '缺省时 general 族用 general、其余用 common')
         .option('--app-id <appId>', '表单所属应用 id（应用主键 fdId）。给出后默认走 modeling 族，写入 fdAppId')
         .option('--fd-entity-id <id>', '业务建模对应 appId / 应用模块对应 templateId（默认取 --app-id）')
         .option('--fd-entity-name <name>', '所属实体 model 名称，例如 com.xxx.YourEntity')
         .option('--fd-entity-key <key>', '实体扩展键（预留）')
         .option('--fd-run-entity-name <name>', '表单运行时实体名称')
         .option('--table-name <name>', '主表名（不传则调用对应接口自动生成）')
+        .option('--category-table-name <name>', '分类表名（--type category，不传自动生成）')
+        .option('--template-table-name <name>', '模板表名（--type category，不传自动生成）')
+        .option('--polymers-table-name <name>', '聚合表名（--type simpleCategory，不传自动生成）')
+        .option('--share-category <code>', '共享已有分类表单的分类（--type category，传对方 fdCode）')
+        .option('--no-support-hierarchy', '分类层级为单层级（默认多层级；简单分类强制多层级）')
         .option('--api <family>', '接口族：auto（默认）| modeling | general | design')
         .option('--group-id <fdGroupId>', '表单所属分组 id（modeling 族）')
         .option('--edit-draft', '草稿状态允许编辑（modeling 族，默认 true）')
@@ -736,6 +893,12 @@ function registerFormCommand(program) {
         const client = createClient(opts);
         const appId = opts.appId;
         const explicitType = opts.type;
+        // 分类表单 / 简单分类表单：走 categoryModel 链路（与普通表单完全不同的接口与表结构）
+        const categoryType = normalizeCategoryType(explicitType);
+        if (categoryType) {
+            await createCategoryForm(client, opts, categoryType);
+            return;
+        }
         const parsedType = explicitType ? parseFormType(explicitType) : undefined;
         const { family, mechanismEntityName, mechanismEntityCode } = generatorOptions(opts, parsedType, appId);
         // 未显式指定类型时：审批意见表单(general) 用 2，其余（含建模应用表单）用 1（普通表单）
@@ -1055,6 +1218,23 @@ function registerFormCommand(program) {
         .option('--json', '以 JSON 输出')
         .action(async (opts) => {
         const client = createClient(opts);
+        // 分类表单 / 简单分类表单与普通表单不在同一张表，优先按分类表单读取
+        let categoryVo;
+        try {
+            categoryVo = await formDefine_1.categoryModelApi.get(client, opts.id);
+        }
+        catch {
+            categoryVo = undefined;
+        }
+        if (categoryVo?.fdId) {
+            logger_1.logger.json(categoryVo);
+            const isSimple = categoryVo.fdType === 2;
+            logger_1.logger.info(logger_1.color.gray(`类型：${isSimple ? '简单分类表单' : '分类表单'}　主表：${categoryVo.fdMainTableName ?? ''}` +
+                (isSimple
+                    ? `　聚合表：${categoryVo.fdPolymersTableName ?? ''}`
+                    : `　分类表：${categoryVo.fdCategoryTableName ?? ''}　模板表：${categoryVo.fdTemplateTableName ?? ''}`)));
+            return;
+        }
         let vo;
         // 依次尝试 建模应用接口 -> 审批意见表单接口 -> 表单引擎接口
         try {