weaver-e10-builder 1.0.10-beta → 1.0.12-beta

package/dist/commands/form-serial-mark.js

@@ -1,31 +1,340 @@
+import { readFileSync } from 'node:fs';
 import { AuthSession } from '../core/auth.js';
 import { ApiClient } from '../core/client.js';
 /**
- * form serial-mark — 复杂编号（markField 年份编号，如 XM-2026-001）。
+ * form serial-mark — 复杂编号（markField）命令组。
  *
- * 依据 scaffold-apis/ebuilder-form/ebuilder-form-codingrule.md（权威流程）：
- *   1) GET  mark/markSet/getEbMarkTargetId?apid → targetId（后续接口的 workflowId/targetId）
- *   2) GET  workflow/pathdef/mark/markSet/getMarkSetForm?workflowId → data.data.numberingRules（默认规则 ID）
- *   3) POST workflow/pathdef/mark/markSet/saveSingleMarkDef（numberingRules=上一步）→ data.markDefId（真实编码定义 ID）
- *   4) POST mark/markSet/saveOrUpdate?apid（id:"" 新增绑定）→ 绑定字段
- *   5) GET  workflow/pathdef/mark/markField/getMarkFieldEditTable?markDefId&workflowId → 当前编号组成（默认年+流水）
- *   6) 按需修改组成（去年/改流水位数/加固定内容 FIX_CONTEXT）→ POST .../markField/saveMarkField
- * 解除编号：POST mark/markSet/updateEbMarkDeleteType（multipart，ids=<绑定记录id>）
+ * 平台编号由若干"段"按 position 顺序拼接，段类型：
+ *   FIX_CONTEXT(固定内容) / DATE_YEAR(年) / SERIAL_NUMBER(流水号) /
+ *   FORM_FIELD(表单字段值) / SYSTEM_FIELD(系统字段:创建人/创建人所属部门) / DATE(日期)
  *
- * 关键：markDefId 必须来自 saveSingleMarkDef 返回（不能用 generatorIds 自造）；编号组成要基于
- * getMarkFieldEditTable 返回的原始对象归一化后修改（seqAlone 数组→标量、带 id），不能精简字段。
+ * 段对象必须来自 getMarkFieldAddData 预生成（含 id/newData/markExtend），不能自造。
+ * markDefId 必须来自 saveSingleMarkDef（不能用 generatorIds，幂等返回 numberingRules）。
+ * seqAlone 读是数组、写要数字（["DATE_YEAR"]→1），不能原样回写读回值。
+ * saveMarkField 是 upsert-by-id + delDefIds 删多余，不传 delDefIds 会累积段。
+ *
+ * 依据 scaffold-apis/ebuilder-form/ebuilder-form-codingrule.md + 浏览器抓包 monitor_1788252252375。
+ *
+ * 命令组：
+ *   read          查看编号配置（绑定/组成/代字）
+ *   set           基础编号（前缀+年+分隔符+流水，含 --year-format/--no-zero）
+ *   add-segment   追加段（field/system/date/fixed，可任意 position）
+ *   short-name    代字/简称（list/set，选项字段值用简称）
+ *   fields        查可绑定为编号目标的字段
+ *   clear         解除编号
  */
+const EB_MARK = '/api/bs/ebuilder/form/mark/markSet';
+const WF_MARK = '/api/bs/ebuilder/form/workflow/pathdef/mark';
+// ─── 共用辅助 ───────────────────────────────────────────────
+/** getEbMarkTargetId → targetId（后续接口当 workflowId 用） */
+async function getTargetId(client, baseUrl, appId) {
+    const res = await client.get(`${baseUrl}${EB_MARK}/getEbMarkTargetId?apid=${appId}`);
+    const id = String(res?.data || '');
+    if (!id)
+        throw new Error(`获取编码目标失败: ${res?.msg || '未知错误'}`);
+    return id;
+}
+/** getMarkSetForm → numberingRules（默认规则ID，等同 markDefId） */
+async function getNumberingRules(client, baseUrl, targetId) {
+    const res = await client.get(`${baseUrl}${WF_MARK}/markSet/getMarkSetForm?workflowId=${targetId}`);
+    const rules = String(res?.data?.data?.numberingRules || '');
+    if (!rules)
+        throw new Error(`获取默认编号规则失败: ${res?.msg || '未知错误'}`);
+    return rules;
+}
+/** saveSingleMarkDef → markDefId（真实编码定义ID，幂等返回 numberingRules） */
+async function saveMarkDef(client, baseUrl, targetId) {
+    const numberingRules = await getNumberingRules(client, baseUrl, targetId);
+    const res = await client.post(`${baseUrl}${WF_MARK}/markSet/saveSingleMarkDef`, {
+        isUse: 1, contentChange: 0, markTriggerType: '1', numberingRules,
+        isFirstSet: false, isMultiMark: '0', reGenerate: 0, workflowSeqalone: 1,
+        disableInput: '0', workflowId: targetId,
+    });
+    const markDefId = String(res?.data?.markDefId || '');
+    if (!markDefId)
+        throw new Error(`创建编码定义失败: ${res?.msg || '未知错误'}`);
+    return markDefId;
+}
+/** getEbMarkSetList → 该表单所有编号绑定 */
+async function getBindings(client, baseUrl, objId, appId) {
+    const res = await client.get(`${baseUrl}${EB_MARK}/getEbMarkSetList?objId=${objId}&apid=${appId}&sourceType=BACK`);
+    return res?.data?.markSetList || [];
+}
+/** 清除某字段的全部旧绑定（防累积），返回清除条数 */
+async function clearFieldBindings(client, baseUrl, objId, appId, fieldId) {
+    const existing = (await getBindings(client, baseUrl, objId, appId))
+        .filter((x) => String(x.markFieldId) === String(fieldId));
+    for (const x of existing) {
+        const f = new URLSearchParams();
+        f.set('ids', String(x.id));
+        await client.postForm(`${baseUrl}${EB_MARK}/updateEbMarkDeleteType?apid=${appId}&objId=${objId}`, f.toString());
+    }
+    return existing.length;
+}
+/** 绑定字段到编号（id:"" 新建，或传已有 bindingId 更新） */
+async function bindField(client, baseUrl, appId, objId, fieldId, targetId, bindingId = '') {
+    const res = await client.post(`${baseUrl}${EB_MARK}/saveOrUpdate?apid=${appId}&objId=${objId}`, {
+        markFieldId: fieldId, objId, id: bindingId, targetId,
+        codeEmptyUpdate: 0, enableReservedCode: 0, enableCustomChange: 0, remarks: '',
+    });
+    if (res?.code !== 200 || !res?.status)
+        throw new Error(`绑定字段失败: ${res?.msg || '未知错误'}`);
+}
+/** getMarkFieldEditTable → 当前编号组成段 */
+async function getEditTable(client, baseUrl, markDefId, targetId) {
+    const res = await client.get(`${baseUrl}${WF_MARK}/markField/getMarkFieldEditTable?markDefId=${markDefId}&workflowId=${targetId}`);
+    return res?.data?.data || [];
+}
+/** 归一化段：seqAlone 数组→数字、补 workflowId/markDefId */
+function normSeg(seg, targetId, markDefId) {
+    const s2 = { ...seg };
+    if (Array.isArray(s2.seqAlone))
+        s2.seqAlone = s2.seqAlone.length ? 1 : 0;
+    const sa = String(s2.seqAlone);
+    if (sa === '1' || sa === 'true')
+        s2.seqAlone = 1;
+    else if (s2.seqAlone === undefined || sa === '' || sa === 'false' || sa === '0' || sa === '[]')
+        s2.seqAlone = 0;
+    s2.workflowId = targetId;
+    s2.markDefId = markDefId;
+    return s2;
+}
+/** getMarkFieldAddData → 取预生成段对象（data[0]） */
+async function getAddData(client, baseUrl, params, targetId) {
+    const qs = new URLSearchParams({
+        sub: '-2', other: '0', year: '-2', yearFormat: '0', yearMonthDay: '-2',
+        dep: '-2', otherType: '0', parentSub: '-2', hourMinSec: '-2', month: '-2',
+        hourMin: '-2', day: '-2', user: '-2', customRelateobjvalue: '',
+        variableCategory: '100', ...params, workflowId: targetId,
+    }).toString();
+    const res = await client.get(`${baseUrl}${WF_MARK}/markField/getMarkFieldAddData?${qs}`);
+    const arr = res?.data || [];
+    if (!arr.length)
+        throw new Error(`取编号段对象失败: ${res?.msg || '返回空'}`);
+    const seg = arr[0];
+    seg.workflowId = targetId;
+    seg.markDefId = '';
+    return seg;
+}
+/** 取固定内容段（FIX_CONTEXT） */
+async function getFixSeg(client, baseUrl, baseFieldId, targetId, markDefId, value) {
+    const seg = await getAddData(client, baseUrl, {
+        showTypeItem: 'fixContent', relateType: 'dep', baseType: baseFieldId,
+        dateType: 'yearMonthDay', selectType: '0', systemField: '0',
+    }, targetId);
+    seg.relateObjValue = value;
+    seg.markDefId = markDefId;
+    return seg;
+}
+/** 取表单字段段（FORM_FIELD）：baseType=取值字段 fieldId，返回段 markExtend=103（代字） */
+async function getFieldSeg(client, baseUrl, fieldId, targetId, markDefId) {
+    const seg = await getAddData(client, baseUrl, {
+        showTypeItem: 'baseType', relateType: 'dep', baseType: fieldId,
+        dateType: 'yearMonthDay', selectType: '0', systemField: '0',
+    }, targetId);
+    seg.markDefId = markDefId;
+    return seg;
+}
+/** 取系统字段段（SYSTEM_FIELD）：systemField 0=创建人 1=创建人所属部门（markExtend=101 部门代字） */
+async function getSystemSeg(client, baseUrl, baseFieldId, targetId, markDefId, systemField) {
+    const seg = await getAddData(client, baseUrl, {
+        showTypeItem: 'systemField', relateType: 'dep', baseType: baseFieldId,
+        dateType: 'yearMonthDay', selectType: '0', systemField,
+    }, targetId);
+    seg.markDefId = markDefId;
+    return seg;
+}
+/** 取字段的编号上下文：优先用已绑定 markDef（持久化 targetId），无则按 createNew 决定是否新建。
+ *  注意：getEbMarkTargetId 每次返回新 targetId，故已有绑定时必须用绑定记录里的 targetId，
+ *  否则 saveSingleMarkDef 会建新 markDef，旧 markDef 上的段/代字数据被孤立。 */
+async function getMarkContext(client, baseUrl, appId, objId, fieldId, createNew) {
+    const bindings = (await getBindings(client, baseUrl, objId, appId))
+        .filter((b) => String(b.markFieldId) === String(fieldId));
+    if (bindings.length) {
+        const b = bindings[0];
+        const targetId = String(b.targetId);
+        let markDefId = '';
+        try {
+            markDefId = await getNumberingRules(client, baseUrl, targetId);
+        }
+        catch { /* markSet 未初始化 */ }
+        return { targetId, markDefId, bindingId: String(b.id) };
+    }
+    if (!createNew)
+        return null;
+    const targetId = await getTargetId(client, baseUrl, appId);
+    const markDefId = await saveMarkDef(client, baseUrl, targetId);
+    await bindField(client, baseUrl, appId, objId, fieldId, targetId, '');
+    return { targetId, markDefId, bindingId: '' };
+}
+/** saveMarkField → 保存编号组成（upsert + delDefIds 删多余） */
+async function saveSegments(client, baseUrl, targetId, markDefId, markFields, delDefIds = []) {
+    const res = await client.post(`${baseUrl}${WF_MARK}/markField/saveMarkField`, {
+        markFields, delDefIds, workflowId: targetId, markDefId,
+    });
+    if (res?.code !== 200 || !res?.status)
+        throw new Error(`保存编号组成失败: ${res?.msg || '未知错误'}`);
+}
+/** 查某 FORM_FIELD 段对应字段的代字列表 */
+async function getShortNames(client, baseUrl, markDefId, targetId, fieldId) {
+    const res = await client.post(`${baseUrl}${WF_MARK}/shortNameSetting/getShortNameSettingEditTable`, {
+        current: 1, pageSize: 100, markDefId, workflowId: targetId, fieldId,
+    });
+    return res?.data?.data || [];
+}
+/** 保存代字 */
+async function saveShortNames(client, baseUrl, list) {
+    const res = await client.post(`${baseUrl}${WF_MARK}/shortNameSetting/saveShortNameSetting`, { shortNameSettingList: list });
+    if (res?.code !== 200 || !res?.status)
+        throw new Error(`保存代字失败: ${res?.msg || '未知错误'}`);
+}
+/** 段类型 → 中文 */
+const SEG_TYPE_LABEL = {
+    FIX_CONTEXT: '固定内容', DATE_YEAR: '年', SERIAL_NUMBER: '流水号位数',
+    FORM_FIELD: '表单字段', SYSTEM_FIELD: '系统字段', DATE_MONTH: '月', DATE_DAY: '日',
+    DATE: '日期',
+};
+/** 把段声明（{type,...}）映射为平台段对象。year/serial 复用 raw 默认段（带 id），
+ *  其余类型走 getMarkFieldAddData 预生成。 */
+async function buildSegment(def, client, baseUrl, boundFieldId, targetId, markDefId, rawByType) {
+    const alone = def.alone ? 1 : 0;
+    switch (def.type) {
+        case 'fixed':
+            if (def.value === undefined)
+                throw new Error('fixed 段需要 value');
+            return await getFixSeg(client, baseUrl, boundFieldId, targetId, markDefId, String(def.value));
+        case 'year': {
+            const raw = rawByType('DATE_YEAR');
+            if (!raw)
+                throw new Error('无默认年份段（markDef 未初始化）');
+            const seg = normSeg(raw, targetId, markDefId);
+            seg.markExtend = def.format === 'two' ? '1' : '0'; // 0=四位(2026) 1=两位(26)
+            // alone:true → 按年份单独流水（DATE_YEAR seqAlone=1，流水号每年重新计数）
+            seg.seqAlone = def.alone === false ? 0 : 1;
+            return seg;
+        }
+        case 'serial': {
+            const raw = rawByType('SERIAL_NUMBER');
+            if (!raw)
+                throw new Error('无默认流水段（markDef 未初始化）');
+            const seg = normSeg(raw, targetId, markDefId);
+            seg.relateObjValue = Number(def.digits) || 4;
+            seg.seqAlone = def.zero === false ? 0 : 1; // 补零 0001
+            return seg;
+        }
+        case 'field': {
+            if (!def.fieldId)
+                throw new Error('field 段需要 fieldId');
+            const seg = await getFieldSeg(client, baseUrl, String(def.fieldId), targetId, markDefId);
+            seg.seqAlone = alone;
+            return seg;
+        }
+        case 'system': {
+            const sf = def.systemField === 'creator-dept' ? '1' : '0'; // 0=创建人 1=创建人所属部门
+            const seg = await getSystemSeg(client, baseUrl, boundFieldId, targetId, markDefId, sf);
+            seg.seqAlone = alone;
+            return seg;
+        }
+        case 'date': {
+            const src = def.source === 'current' ? '-2' : (def.source || '-2');
+            const seg = await getAddData(client, baseUrl, {
+                showTypeItem: 'dateType', relateType: 'dep', baseType: boundFieldId,
+                dateType: 'yearMonthDay', yearMonthDay: src, selectType: '0', systemField: '0',
+            }, targetId);
+            seg.markDefId = markDefId;
+            seg.seqAlone = alone;
+            return seg;
+        }
+        default:
+            throw new Error(`不支持的段类型: ${def.type}（fixed/year/serial/field/system/date）`);
+    }
+}
+/** 段声明 → 可读描述 */
+function segDesc(def) {
+    switch (def.type) {
+        case 'fixed': return `固定(${def.value})`;
+        case 'year': return `年(${def.format || 'four'})`;
+        case 'serial': return `${def.digits || 4}位流水${def.zero === false ? '(不补零)' : ''}`;
+        case 'field': return `字段(${def.fieldId})`;
+        case 'system': return def.systemField === 'creator-dept' ? '创建人部门' : '创建人';
+        case 'date': return `日期(${def.format || 'yyyyMMdd'})`;
+        default: return def.type;
+    }
+}
+// ─── 命令组注册 ─────────────────────────────────────────────
 export function registerFormSerialMarkCommands(form, program) {
-    form.command('serial-mark')
-        .description('配置/解除复杂编号（markField：固定内容+年份+流水号，支持 XM-2026-001 年份编号）')
+    const sm = form.command('serial-mark')
+        .description('复杂编号（markField：固定内容+年份+流水+表单字段+系统字段+代字）');
+    // ─── read ───────────────────────────────────────────────
+    sm.command('read')
+        .description('查看编号配置（绑定字段 + 组成段 + 代字）')
+        .argument('<objId>', '表单 objId')
+        .argument('<appId>', '应用 ID')
+        .action(async (objId, appId) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            process.exit(1);
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        const bindings = await getBindings(client, baseUrl, objId, appId);
+        if (!bindings.length) {
+            console.log('未配置编号');
+            return;
+        }
+        const out = [];
+        for (const b of bindings) {
+            const fieldId = String(b.markFieldId);
+            const targetId = String(b.targetId);
+            const showName = b.showName || '';
+            let markDefId = '';
+            try {
+                markDefId = await getNumberingRules(client, baseUrl, targetId);
+            }
+            catch { /* markSet 未初始化 */ }
+            const segs = markDefId ? await getEditTable(client, baseUrl, markDefId, targetId) : [];
+            const segList = segs
+                .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
+                .map((s) => ({
+                type: s.markFieldType, label: SEG_TYPE_LABEL[s.markFieldType] || s.markFieldType,
+                value: s.relateObjValue ?? '', markExtend: s.markExtend ?? '', seqAlone: s.seqAlone,
+            }));
+            // 对 FORM_FIELD 段补代字
+            for (const seg of segList) {
+                if (seg.type === 'FORM_FIELD' && markDefId) {
+                    try {
+                        const names = await getShortNames(client, baseUrl, markDefId, targetId, String(seg.value));
+                        seg.shortNames = names.filter((n) => n.abbr).map((n) => `${n.showName}=${n.abbr}`);
+                    }
+                    catch { /* 无代字 */ }
+                }
+            }
+            out.push({ fieldId, showName, targetId, markDefId, segments: segList });
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(out, null, 2));
+        }
+        else {
+            for (const b of out) {
+                console.log(`字段 ${b.fieldId} (${b.showName || '?'})  targetId=${b.targetId} markDefId=${b.markDefId}`);
+                for (const s of b.segments) {
+                    const ext = s.markExtend ? ` 代字(${s.markExtend})` : '';
+                    const sa = s.seqAlone;
+                    const isAlone = sa === 1 || sa === '1' || (Array.isArray(sa) && sa.length > 0);
+                    const alone = isAlone ? ' [单独流水]' : '';
+                    const sn = s.shortNames?.length ? ` 代字映射: ${s.shortNames.join(', ')}` : '';
+                    console.log(`  ${s.label}: ${s.value}${ext}${alone}${sn}`);
+                }
+            }
+        }
+    });
+    // ─── set（配置编号：--segments 多段组合，唯一正典方式）─────────────
+    sm.command('set')
+        .description('配置编号规则。--segments <json> 多段组合（数组顺序即编号拼接顺序，支持任意规则直接组合），重跑全量替换')
         .argument('<objId>', '表单 objId')
         .argument('<appId>', '应用 ID')
         .argument('<fieldId>', '要生成编号的字段 ID')
-        .option('--prefix <text>', '固定内容前缀，如 "XM-"（FIX_CONTEXT）')
-        .option('--year', '带年份段（DATE_YEAR）。缺省不带年份（仅 前缀+流水）')
-        .option('--serial <n>', '流水号位数（SERIAL_NUMBER，如 4=0001）', '4')
-        .option('--sep <text>', '年→流水之间的分隔符（独立 FIX_CONTEXT 段，默认 "-"）', '-')
-        .option('--clear', '解除该字段的编号')
+        .requiredOption('--segments <json>', '编号段配置 JSON（@文件 或 内联数组），按顺序决定段顺序。段类型: fixed/year/serial/field/system/date')
         .action(async (objId, appId, fieldId, cmdOpts) => {
         const opts = program.opts();
         const auth = await AuthSession.fromOptions(opts);
@@ -33,135 +342,293 @@ export function registerFormSerialMarkCommands(form, program) {
             process.exit(1);
         const client = new ApiClient(auth);
         const baseUrl = auth.getBaseUrl();
-        const MARK_API = `${baseUrl}/api/bs/ebuilder/form/mark/markSet`;
-        const MARK_WF_API = `${baseUrl}/api/bs/ebuilder/form/workflow/pathdef/mark/markSet`;
-        const MARK_FIELD_API = `${baseUrl}/api/bs/ebuilder/form/workflow/pathdef/mark/markField`;
-        // 1. targetId
-        const tRes = await client.get(`${MARK_API}/getEbMarkTargetId?apid=${appId}`);
-        const targetId = String(tRes?.data || '');
-        if (!targetId) {
-            console.error(`获取编码目标失败: ${tRes?.msg || '未知错误'}`);
-            process.exit(1);
-        }
-        // --clear：查绑定记录 id → 解除
-        if (cmdOpts.clear) {
-            let bindingId = '';
-            try {
-                const q = await client.get(`${MARK_API}/getEbMarkSetList?objId=${objId}&apid=${appId}&sourceType=BACK`);
-                const s = (q?.data?.markSetList || []).find((x) => String(x.markFieldId) === String(fieldId));
-                bindingId = String(s?.id || '');
+        let segStr = cmdOpts.segments;
+        if (segStr.startsWith('@'))
+            segStr = readFileSync(segStr.slice(1), 'utf-8');
+        let segDefs;
+        try {
+            segDefs = JSON.parse(segStr);
+        }
+        catch {
+            console.error('--segments JSON 解析失败');
+            process.exit(1);
+        }
+        if (!Array.isArray(segDefs) || !segDefs.length) {
+            console.error('--segments 必须是非空数组');
+            process.exit(1);
+        }
+        // 复用已有 markDef（保代字/绑定），无则新建并绑定
+        const ctx = await getMarkContext(client, baseUrl, appId, objId, fieldId, true);
+        if (!ctx) {
+            console.error('无法获取编号上下文');
+            process.exit(1);
+        }
+        const { targetId, markDefId } = ctx;
+        // 读现有段（复用 year/serial 的 id，其余旧段 id 进 delDefIds）
+        const raw = markDefId ? await getEditTable(client, baseUrl, markDefId, targetId) : [];
+        const rawByType = (t) => raw.find((x) => x.markFieldType === t);
+        const final = [];
+        const shortNameBatches = [];
+        for (const def of segDefs) {
+            final.push(await buildSegment(def, client, baseUrl, fieldId, targetId, markDefId, rawByType));
+            if (def.type === 'field' && def.fieldId && def.shortName) {
+                shortNameBatches.push({ fieldId: String(def.fieldId), map: def.shortName });
+            }
+        }
+        final.forEach((s, i) => { s.position = i; });
+        // delDefIds：现有段不在 final（按 id）的全部删除（全量替换，防累积）
+        const finalIds = new Set(final.filter((s) => s.id).map((s) => String(s.id)));
+        const delDefIds = raw.filter((s) => s.id && !finalIds.has(String(s.id))).map((s) => String(s.id));
+        await saveSegments(client, baseUrl, targetId, markDefId, final, delDefIds);
+        // inline 代字（field 段带 shortName）
+        for (const sn of shortNameBatches) {
+            const existing = await getShortNames(client, baseUrl, markDefId, targetId, sn.fieldId);
+            const byName = new Map(existing.map((n) => [String(n.showName), n]));
+            const list = [];
+            let idx = 0;
+            for (const [showName, abbr] of Object.entries(sn.map)) {
+                const old = byName.get(showName);
+                list.push({ showName, markDefId, abbr, fieldValue: old?.fieldValue || '', fieldId: sn.fieldId, id: old?.id ?? idx++ });
             }
-            catch { /* 查询失败则无从清除 */ }
-            if (!bindingId) {
-                console.error('未找到该字段的编号绑定，无需解除');
+            await saveShortNames(client, baseUrl, list);
+        }
+        const desc = segDefs.map(segDesc).join(' + ');
+        console.log(opts.json
+            ? JSON.stringify({ success: true, targetId, markDefId, fieldId, segments: final.length, shortNames: shortNameBatches.length })
+            : `编号已配置(${final.length}段): ${desc} → 绑定字段 ${fieldId}`);
+    });
+    // ─── add-segment（追加段）─────────────────────────────────
+    sm.command('add-segment')
+        .description('给编号追加段。--type field/system/date/fixed；保留已有段，新段默认追加到末尾')
+        .argument('<objId>', '表单 objId')
+        .argument('<appId>', '应用 ID')
+        .argument('<fieldId>', '已绑定编号的字段 ID')
+        .requiredOption('--type <type>', '段类型: field(表单字段) / system(系统字段) / date(日期) / fixed(固定内容)')
+        .option('--field-id <id>', '取值字段 ID（type=field 时必填；type=date 且 --source 为字段时用）')
+        .option('--system-field <which>', '系统字段: creator(创建人) / creator-dept(创建人所属部门)。type=system 时必填')
+        .option('--value <text>', '固定内容值（type=fixed 时必填）')
+        .option('--date-format <fmt>', '日期格式: yyyy / yyyyMM / yyyyMMdd（type=date 时，缺省 yyyyMMdd）', 'yyyyMMdd')
+        .option('--source <src>', '日期来源: current(当前日期,缺省) / <字段ID>（type=date 时）', 'current')
+        .option('--alone', '该段机构单独流水（seqAlone=1）')
+        .option('--position <n>', '插入位置（0 起，缺省追加末尾）')
+        .action(async (objId, appId, fieldId, cmdOpts) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            process.exit(1);
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        // 取编号上下文：已有绑定用旧 markDef（保住段/代字），无则新建
+        const ctx = await getMarkContext(client, baseUrl, appId, objId, fieldId, true);
+        if (!ctx) {
+            console.error('无法获取编号上下文');
+            process.exit(1);
+        }
+        const { targetId, markDefId } = ctx;
+        // 取现有段（复用 id，防累积）
+        const existing = markDefId ? await getEditTable(client, baseUrl, markDefId, targetId) : [];
+        let newSeg;
+        if (cmdOpts.type === 'field') {
+            if (!cmdOpts.fieldId) {
+                console.error('type=field 需要 --field-id');
                 process.exit(1);
             }
-            const form = new URLSearchParams();
-            form.set('ids', bindingId);
-            const delRes = await client.postForm(`${MARK_API}/updateEbMarkDeleteType?apid=${appId}&objId=${objId}`, form.toString());
-            if (delRes?.code === 200 && delRes?.status)
-                console.log(`已解除字段 ${fieldId} 的编号绑定`);
-            else {
-                console.error(`解除失败: ${delRes?.msg || '未知错误'}`);
+            newSeg = await getFieldSeg(client, baseUrl, cmdOpts.fieldId, targetId, markDefId);
+        }
+        else if (cmdOpts.type === 'system') {
+            const sf = cmdOpts.systemField === 'creator-dept' ? '1' : '0';
+            newSeg = await getSystemSeg(client, baseUrl, fieldId, targetId, markDefId, sf);
+        }
+        else if (cmdOpts.type === 'date') {
+            const src = cmdOpts.source === 'current' ? '-2' : (cmdOpts.source || '-2');
+            newSeg = await getAddData(client, baseUrl, {
+                showTypeItem: 'dateType', relateType: 'dep', baseType: fieldId,
+                dateType: 'yearMonthDay', yearMonthDay: src, selectType: '0', systemField: '0',
+            }, targetId);
+            newSeg.markDefId = markDefId;
+        }
+        else if (cmdOpts.type === 'fixed') {
+            if (cmdOpts.value === undefined) {
+                console.error('type=fixed 需要 --value');
                 process.exit(1);
             }
-            return;
+            newSeg = await getFixSeg(client, baseUrl, fieldId, targetId, markDefId, cmdOpts.value);
         }
-        // 2. 默认规则 ID（getMarkSetForm → numberingRules）
-        const gsf = await client.get(`${MARK_WF_API}/getMarkSetForm?workflowId=${targetId}`);
-        const numberingRules = String(gsf?.data?.data?.numberingRules || '');
-        if (!numberingRules) {
-            console.error(`获取默认编号规则失败: ${gsf?.msg || '未知错误'}`);
+        else {
+            console.error(`不支持的 type: ${cmdOpts.type}（field/system/date/fixed）`);
             process.exit(1);
         }
-        // 2.5 清除该字段已有编号绑定（防累积：重跑时旧绑定残留带年份，与新绑定冲突 → "KH-20260001"）
+        // seqAlone
+        newSeg.seqAlone = cmdOpts.alone ? 1 : 0;
+        // 合并：现有段（归一化，保留 id）+ 新段
+        const merged = existing.map((s) => normSeg(s, targetId, markDefId));
+        merged.push(newSeg);
+        // position：指定位置插入，否则末尾
+        const pos = cmdOpts.position !== undefined ? parseInt(cmdOpts.position, 10) : merged.length - 1;
+        // 先把新段放最后，再按 position 重排（简单做法：移到指定下标）
+        const idx = merged.length - 1;
+        if (pos >= 0 && pos < idx) {
+            const [item] = merged.splice(idx, 1);
+            merged.splice(pos, 0, item);
+        }
+        merged.forEach((s, i) => { s.position = i; });
+        await saveSegments(client, baseUrl, targetId, markDefId, merged, []);
+        // 回读验证
+        const after = await getEditTable(client, baseUrl, markDefId, targetId);
+        console.log(opts.json
+            ? JSON.stringify({ success: true, targetId, markDefId, fieldId, segments: after.length })
+            : `已追加 ${cmdOpts.type} 段 → 编号现有 ${after.length} 段`);
+    });
+    // ─── short-name（代字/简称）──────────────────────────────
+    const sn = sm.command('short-name').description('代字/简称设置（选项字段值用简称拼进编号）');
+    sn.command('list')
+        .description('查看某字段各选项的代字')
+        .argument('<objId>', '表单 objId')
+        .argument('<appId>', '应用 ID')
+        .argument('<fieldId>', '选项字段 ID（FORM_FIELD 段的取值字段）')
+        .action(async (objId, appId, fieldId) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            process.exit(1);
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        // 代字属于编号绑定字段的 markDef，fieldId 是被引用的 Select 字段（非绑定字段）。
+        // 从表单任意绑定取 targetId/markDefId，再用 fieldId 查代字。
+        const bindings = await getBindings(client, baseUrl, objId, appId);
+        if (!bindings.length) {
+            console.error('该表单未配置编号，无法查代字');
+            process.exit(1);
+        }
+        const targetId = String(bindings[0].targetId);
+        let markDefId = '';
         try {
-            const q = await client.get(`${MARK_API}/getEbMarkSetList?objId=${objId}&apid=${appId}&sourceType=BACK`);
-            const existing = (q?.data?.markSetList || []).filter((x) => String(x.markFieldId) === String(fieldId));
-            for (const x of existing) {
-                const f = new URLSearchParams();
-                f.set('ids', String(x.id));
-                await client.postForm(`${MARK_API}/updateEbMarkDeleteType?apid=${appId}&objId=${objId}`, f.toString());
-            }
-            if (existing.length)
-                console.error(`  已清除 ${existing.length} 个旧编号绑定`);
-        }
-        catch { /* 清除失败不阻断 */ }
-        // 3. 创建编码定义 → 真实 markDefId
-        const smd = await client.post(`${MARK_WF_API}/saveSingleMarkDef`, {
-            isUse: 1, contentChange: 0, markTriggerType: '1', numberingRules,
-            isFirstSet: true, isMultiMark: '0', reGenerate: 0, workflowSeqalone: 1,
-            disableInput: '0', workflowId: targetId,
-        });
-        const markDefId = String(smd?.data?.markDefId || '');
+            markDefId = await getNumberingRules(client, baseUrl, targetId);
+        }
+        catch { /* */ }
         if (!markDefId) {
-            console.error(`创建编码定义失败: ${smd?.msg || '未知错误'}`);
-            process.exit(1);
-        }
-        // 4. 绑定到字段（新建 id:""）
-        const bindRes = await client.post(`${MARK_API}/saveOrUpdate?apid=${appId}&objId=${objId}`, {
-            markFieldId: fieldId, objId, id: '', targetId,
-            codeEmptyUpdate: 0, enableReservedCode: 0, enableCustomChange: 0, remarks: '',
-        });
-        if (bindRes?.code !== 200 || !bindRes?.status) {
-            console.error(`绑定字段失败: ${bindRes?.msg || '未知错误'}`);
-            process.exit(1);
-        }
-        // 5. 读当前编号组成（默认 年+流水）
-        const et = await client.get(`${MARK_FIELD_API}/getMarkFieldEditTable?markDefId=${markDefId}&workflowId=${targetId}`);
-        const raw = et?.data?.data || [];
-        // 6. 归一化 raw 段（seqAlone 数组→标量；保留 id/workflowId/markDefId），按 前缀→年→流水 顺序重排
-        const norm = (seg) => {
-            const s2 = { ...seg };
-            if (Array.isArray(s2.seqAlone))
-                s2.seqAlone = s2.seqAlone.length ? '1' : '0';
-            if (String(s2.seqAlone) === '1' || String(s2.seqAlone) === 'true')
-                s2.seqAlone = 1;
-            s2.workflowId = targetId;
-            s2.markDefId = markDefId;
-            return s2;
-        };
-        const byType = (type) => raw.find((x) => x.markFieldType === type);
-        const getFixCfg = async () => {
-            const addFix = await client.get(`${MARK_FIELD_API}/getMarkFieldAddData?showTypeItem=fixContent&relateType=dep&baseType=${fieldId}&workflowId=${targetId}&variableCategory=100&dateType=yearMonthDay&selectType=0&systemField=0`);
-            return (addFix?.data || [])[0] || {};
-        };
-        const final = [];
-        if (cmdOpts.prefix)
-            final.push({ ...await getFixCfg(), relateObjValue: cmdOpts.prefix, workflowId: targetId, markDefId });
-        if (cmdOpts.year && byType('DATE_YEAR'))
-            final.push(norm(byType('DATE_YEAR')));
-        if (cmdOpts.year && byType('SERIAL_NUMBER') && cmdOpts.sep) {
-            // 年→流水之间的分隔符是独立 FIX_CONTEXT 段（对齐浏览器：HTMC-2026-0001 的 "-"）
-            final.push({ ...await getFixCfg(), relateObjValue: cmdOpts.sep, workflowId: targetId, markDefId });
-        }
-        if (byType('SERIAL_NUMBER')) {
-            const serialSeg = norm(byType('SERIAL_NUMBER'));
-            serialSeg.relateObjValue = parseInt(cmdOpts.serial || '4', 10) || 4; // 流水位数
-            serialSeg.seqAlone = 1; // 对齐浏览器配置：序列独立 → 补零 0001
-            final.push(serialSeg);
-        }
-        final.forEach((seg, i) => { seg.position = i; });
-        // 不在 final 中的默认段（如未指定 --year 时的 DATE_YEAR）必须显式删除，
-        // 否则 saveMarkField 保留默认组成 → 年份残留，显示成 "2026KH-0001" 而非 "KH-0001"
-        const finalTypes = new Set(final.map((s) => s.markFieldType));
-        const delDefIds = raw
-            .filter((s) => s.id && !finalTypes.has(s.markFieldType))
-            .map((s) => String(s.id));
-        // 7. 保存编号组成
-        const saveRes = await client.post(`${MARK_FIELD_API}/saveMarkField`, {
-            markFields: final, markDefId, delDefIds, workflowId: targetId,
-        });
-        if (saveRes?.code !== 200 || !saveRes?.status) {
-            console.error(`保存编号组成失败: ${saveRes?.msg || '未知错误'}`);
-            process.exit(1);
-        }
-        // 注：被编码字段平台自动设为只读（无需 CLI 处理）
-        const parts = [cmdOpts.prefix, cmdOpts.year ? '年份' : '', `${cmdOpts.serial}位流水`].filter(Boolean);
-        const msg = opts.json
-            ? JSON.stringify({ success: true, targetId, markDefId, fieldId })
-            : `编号已配置: ${parts.join('+')} → 绑定字段 ${fieldId}`;
-        console.log(msg);
+            console.error('无法获取编号定义 markDefId');
+            process.exit(1);
+        }
+        const list = await getShortNames(client, baseUrl, markDefId, targetId, fieldId);
+        if (opts.json) {
+            console.log(JSON.stringify(list, null, 2));
+        }
+        else {
+            console.log(`共 ${list.length} 个选项:`);
+            for (const n of list)
+                console.log(`  ${n.showName}  代字: ${n.abbr || '(未设)'}`);
+        }
+    });
+    sn.command('set')
+        .description('批量设置代字。--map 为 JSON 映射（选项名→代字），如 @map.json 或 {"研发":"YF"}')
+        .argument('<objId>', '表单 objId')
+        .argument('<appId>', '应用 ID')
+        .argument('<fieldId>', '选项字段 ID')
+        .requiredOption('--map <json>', '代字映射 JSON（{"研发":"YF","实施":"SS"}）或 @文件')
+        .action(async (objId, appId, fieldId, cmdOpts) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            process.exit(1);
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        // 解析映射
+        let mapStr = cmdOpts.map;
+        if (mapStr.startsWith('@'))
+            mapStr = readFileSync(mapStr.slice(1), 'utf-8');
+        const map = JSON.parse(mapStr);
+        // 从表单绑定取 markDefId（代字挂在编号绑定的 markDef 上，fieldId 是被引用 Select 字段）
+        const bindings = await getBindings(client, baseUrl, objId, appId);
+        if (!bindings.length) {
+            console.error('该表单未配置编号，无法设代字');
+            process.exit(1);
+        }
+        const targetId = String(bindings[0].targetId);
+        let markDefId = '';
+        try {
+            markDefId = await getNumberingRules(client, baseUrl, targetId);
+        }
+        catch { /* */ }
+        if (!markDefId) {
+            console.error('无法获取编号定义 markDefId');
+            process.exit(1);
+        }
+        const existing = await getShortNames(client, baseUrl, markDefId, targetId, fieldId);
+        // 现有项 id 映射（更新用真实 id，新增用 0/1/2 递增）
+        const byName = new Map(existing.map((n) => [String(n.showName), n]));
+        const list = [];
+        let newIdx = 0;
+        for (const [showName, abbr] of Object.entries(map)) {
+            const old = byName.get(showName);
+            list.push({
+                showName, markDefId, abbr,
+                fieldValue: old?.fieldValue || '',
+                fieldId,
+                id: old?.id ?? newIdx++,
+            });
+        }
+        await saveShortNames(client, baseUrl, list);
+        console.log(opts.json
+            ? JSON.stringify({ success: true, set: list.length })
+            : `已设置 ${list.length} 个代字: ${list.map((n) => `${n.showName}=${n.abbr}`).join(', ')}`);
+    });
+    // ─── fields（查可绑定字段）────────────────────────────────
+    sm.command('fields')
+        .description('查可作为编号目标的字段列表')
+        .argument('<objId>', '表单 objId')
+        .argument('<appId>', '应用 ID')
+        .option('--target-field <fieldId>', '参考字段 ID（可选，过滤可绑定字段）')
+        .action(async (objId, appId, cmdOpts) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            process.exit(1);
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        const params = new URLSearchParams({ objId, apid: appId });
+        params.set('targetMarkField', cmdOpts.targetField || '-2');
+        if (cmdOpts.targetField) {
+            params.set('objId', objId);
+        }
+        const res = await client.get(`${baseUrl}${EB_MARK}/getEbMarkFields?${params.toString()}`);
+        const fields = res?.data || [];
+        if (opts.json) {
+            console.log(JSON.stringify(fields, null, 2));
+        }
+        else {
+            console.log(`共 ${fields.length} 个可绑定字段:`);
+            for (const f of fields)
+                console.log(`  ${f.id}  ${f.showName}  (${f.componentKey || f.type})`);
+        }
+    });
+    // ─── clear（解除编号）─────────────────────────────────────
+    sm.command('clear')
+        .description('解除该字段的编号绑定')
+        .argument('<objId>', '表单 objId')
+        .argument('<appId>', '应用 ID')
+        .argument('<fieldId>', '要解除的字段 ID')
+        .action(async (objId, appId, fieldId) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            process.exit(1);
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        const existing = (await getBindings(client, baseUrl, objId, appId))
+            .filter((x) => String(x.markFieldId) === String(fieldId));
+        if (!existing.length) {
+            console.error('未找到该字段的编号绑定，无需解除');
+            process.exit(1);
+        }
+        for (const x of existing) {
+            const f = new URLSearchParams();
+            f.set('ids', String(x.id));
+            await client.postForm(`${baseUrl}${EB_MARK}/updateEbMarkDeleteType?apid=${appId}&objId=${objId}`, f.toString());
+        }
+        console.log(opts.json
+            ? JSON.stringify({ success: true, fieldId, cleared: existing.length })
+            : `已解除字段 ${fieldId} 的编号绑定（${existing.length} 条）`);
     });
 }
 //# sourceMappingURL=form-serial-mark.js.map