@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/human-summary.js

@@ -0,0 +1,212 @@
+/**
+ * Ticket 49 — the single human-summary source. Every write's plan
+ * ("即将…") and its result ("已…") are produced HERE from the real arguments,
+ * so the reviewed text and the reported text cannot diverge. Summaries are
+ * Chinese, name identity codes (schemaCode / field code / ruleCode / …), use
+ * Chinese field/control type names, and state relation mappings. They are
+ * ADDED beside the integrity fields (performed/readback/fingerprints) and
+ * never replace them.
+ */
+/** Chinese names for the live-accepted field families (skill omc-config-draft-review §2). */
+export const FIELD_TYPE_NAMES_ZH = {
+    SHORT_TEXT: "短文本",
+    LONG_TEXT: "长文本",
+    NUMERICAL: "数值",
+    DATE: "日期",
+    LOGICAL: "布尔",
+    SELECTION: "混合选人",
+    ATTACHMENT: "附件",
+    WORK_SHEET: "关联单选",
+    ADDRESS: "地址",
+    MULT_WORK_SHEET: "关联多选",
+    RADIO: "单选",
+    CHECKBOX: "复选",
+    DROPDOWN_BOX: "下拉",
+    DROPDOWN_MULTI_BOX: "下拉多选",
+    RELEVANCE_DATA: "引用字段",
+    HYPER_LINK: "超链接",
+    TIME: "时间",
+    STAFF_SELECTOR: "人员单选",
+    STAFF_MULTI_SELECTOR: "人员多选",
+    DEPARTMENT_SELECTOR: "部门单选",
+    DEPARTMENT_MULTI_SELECTOR: "部门多选",
+    FORMULA: "公式",
+};
+const DATA_RULE_TYPE_NAMES_ZH = {
+    1: "校验规则",
+    2: "计算拼接",
+    3: "显示规则",
+    4: "必填规则",
+    5: "只读规则",
+};
+function stringArg(args, key) {
+    const value = args[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function fieldTypeZh(propertyType) {
+    const type = String(propertyType ?? "");
+    return FIELD_TYPE_NAMES_ZH[type] ?? (type.length > 0 ? type : "字段");
+}
+function choiceList(choices) {
+    if (!Array.isArray(choices) || choices.length === 0)
+        return undefined;
+    return `，选项：${choices.map(String).join(" / ")}`;
+}
+function relationClause(args) {
+    const relativeCode = stringArg(args, "relativeCode");
+    const options = args.options;
+    let mappings;
+    if (typeof options?.mappings === "string" && options.mappings.trim() && options.mappings.trim() !== "[]") {
+        try {
+            const parsed = JSON.parse(options.mappings);
+            if (Array.isArray(parsed) && parsed.length > 0) {
+                mappings = parsed.map((entry) => `${entry.source ?? "?"}→${entry.target ?? "?"}`).join("、");
+            }
+        }
+        catch {
+            mappings = undefined;
+        }
+    }
+    if (!relativeCode)
+        return "";
+    return `，关联 ${relativeCode}${mappings ? `，带出 ${mappings}` : ""}`;
+}
+function nodeCountOf(nodeGraph) {
+    if (Array.isArray(nodeGraph?.nodes))
+        return nodeGraph.nodes.length;
+    if (typeof nodeGraph?.nodes === "string") {
+        try {
+            const parsed = JSON.parse(nodeGraph.nodes);
+            if (Array.isArray(parsed))
+                return parsed.length;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function noChange(outcome) {
+    return typeof outcome?.performed?.skipped === "string";
+}
+/**
+ * The one human phrase for a write. `phase:"plan"` prefixes 即将 (approval
+ * card), `phase:"done"` prefixes 已 (result). Skipped no-op writes surface as
+ * 无变更 instead of pretending something changed.
+ */
+export function writeSummary(tool, args, outcome, phase = "done") {
+    const phrase = phraseOf(tool, args, outcome);
+    // An explicitly requested cross-application target is named in BOTH the
+    // plan and the result (same source, no divergence).
+    const app = typeof args.applicationCode === "string" && args.applicationCode ? `（应用 ${args.applicationCode}）` : "";
+    const prefix = phase === "plan" ? "即将" : "已";
+    if (noChange(outcome))
+        return `${prefix}${phrase}${app}（无变更：${String(outcome?.performed?.skipped)}）`;
+    return `${prefix}${phrase}${app}`;
+}
+function phraseOf(tool, args, outcome) {
+    const schemaCode = stringArg(args, "schemaCode");
+    switch (tool) {
+        case "model.create":
+            return `创建模型 ${stringArg(args, "name") ?? ""}（${stringArg(args, "code") ?? "?"}），${args.modelType === "TREE" ? "树形" : "列表"}型`;
+        case "model.delete":
+            return `删除模型 ${schemaCode ?? stringArg(args, "code") ?? "?"}`;
+        case "model.deleteMany": {
+            const codes = Array.isArray(args.schemaCodes) ? args.schemaCodes.map(String) : [];
+            return `删除 ${codes.length} 个模型：${codes.join("、")}`;
+        }
+        case "field.create": {
+            const target = stringArg(args, "schemaCode") ?? "?";
+            return `创建字段 ${stringArg(args, "name") ?? ""}（${stringArg(args, "code") ?? "?"}），${fieldTypeZh(args.propertyType)}，挂在 ${target}${relationClause(args)}${choiceList(args.choices) ?? ""}`;
+        }
+        case "field.update":
+            return `更新字段 ${stringArg(args, "code") ?? "?"} 的配置（${schemaCode ?? "?"}）`;
+        case "field.delete":
+            return `删除字段 ${stringArg(args, "code") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "field.publish":
+            return `发布模型 ${schemaCode ?? "?"} 的全部草稿字段（模型级一次发布）`;
+        case "form.draft":
+            return `保存表单 ${stringArg(args, "sheetCode") ?? "?"}（模型 ${schemaCode ?? "?"}）的草稿布局`;
+        case "form.publish":
+            return `发布表单 ${stringArg(args, "sheetCode") ?? "?"}（模型 ${schemaCode ?? "?"}）`;
+        case "configure_model": {
+            const fields = args.fields;
+            const count = Array.isArray(fields) ? fields.length : stringArg(args, "fieldCode") ? 1 : 0;
+            return `创建模型 ${stringArg(args, "name") ?? ""}（${stringArg(args, "code") ?? "?"}）并发布 ${count} 个字段${args.publishForm === true ? "，默认表单已发布" : ""}`;
+        }
+        case "configure_form": {
+            const codes = args.fieldCodes;
+            return `配置并发布表单 ${stringArg(args, "sheetCode") ?? "?"}（模型 ${schemaCode ?? "?"}）${Array.isArray(codes) && codes.length > 0 ? `，绑定字段 ${codes.map(String).join("、")}` : "（绑定全部已发布字段）"}`;
+        }
+        case "configure_rule":
+            return `保存并启用业务规则 ${stringArg(args, "name") ?? ""}（${stringArg(args, "ruleCode") ?? "?"}，模型 ${schemaCode ?? "?"}）`;
+        case "rule.save": {
+            const nodes = nodeCountOf(args.nodeGraph);
+            return `保存业务规则 ${stringArg(args, "name") ?? stringArg(args, "ruleCode") ?? "?"}（${stringArg(args, "ruleCode") ?? "?"}，模型 ${schemaCode ?? "?"}${nodes ? `，图 ${nodes} 节点` : ""}）`;
+        }
+        case "rule.enable":
+            return `启用业务规则 ${stringArg(args, "ruleCode") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "rule.disable":
+            return `停用业务规则 ${stringArg(args, "ruleCode") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "rule.delete":
+            return `删除业务规则 ${stringArg(args, "ruleCode") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "datarule.create":
+        case "datarule.update": {
+            const type = DATA_RULE_TYPE_NAMES_ZH[Number(args.dataRuleType)] ?? `类型${String(args.dataRuleType ?? "?")}`;
+            return `${tool === "datarule.create" ? "创建" : "更新"}字段规则（${stringArg(args, "propertyCode") ?? "?"}，${type}），挂在 ${schemaCode ?? "?"}`;
+        }
+        case "datarule.delete":
+            return `删除字段规则 ${stringArg(args, "id") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "workflow.create":
+            return `创建流程 ${stringArg(args, "name") ?? ""}（${stringArg(args, "code") ?? "?"}，模型 ${schemaCode ?? "?"}）`;
+        case "workflow.update":
+            return `更新流程模板 ${stringArg(args, "code") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "workflow.publish":
+            return `发布流程 ${stringArg(args, "code") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "workflow.bindRule": {
+            const codes = Array.isArray(args.ruleCodes) ? args.ruleCodes.join("、") : stringArg(args, "ruleCode") ?? "?";
+            return `绑定流程事件规则：${stringArg(args, "workflowCode") ?? "?"} 的 ${stringArg(args, "handler") ?? "end"} 处理器 ← ${codes}`;
+        }
+        case "workflow.delete":
+            return `删除流程 ${stringArg(args, "code") ?? "?"}`;
+        case "onlinejs.compose":
+            return `编排并发布表单脚本 customScript（模型 ${schemaCode ?? "?"} / 表单 ${stringArg(args, "sheetCode") ?? "?"}）`;
+        case "service.register":
+            return `注册后端服务 ${stringArg(args, "serviceCode") ?? "?"}`;
+        case "service.delete":
+            return `删除后端服务 ${stringArg(args, "serviceCode") ?? "?"}`;
+        case "method.delete":
+            return `删除业务集成方法 ${stringArg(args, "methodCode") ?? "?"}（服务 ${stringArg(args, "serviceCode") ?? "?"}）`;
+        case "data.save":
+            return args.submit === true
+                ? `保存数据（模型 ${schemaCode ?? "?"}）——submit:true 不走表单提交管线：行落 DRAFT、预置 Create/Update 规则不派发。要建行并触发规则：直接调 data.submit（不带 bizObjectId=新建并提交，行 COMPLETED、规则派发，r5-crm 实证 2026-10-09）；data.save 仅用于存草稿`
+                : `保存数据（模型 ${schemaCode ?? "?"}）`;
+        case "data.update":
+            return `更新数据 ${stringArg(args, "bizObjectId") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "data.submit":
+            return `提交数据（模型 ${schemaCode ?? "?"}${stringArg(args, "workItemId") ? "，审批待办" : ""}）`;
+        case "data.delete": {
+            const ids = Array.isArray(args.bizObjectIds) ? args.bizObjectIds.map(String) : [];
+            const target = ids.length > 0 ? `${ids.length} 条数据（${ids.join("、")}）` : (stringArg(args, "bizObjectId") ?? "?");
+            return `删除数据 ${target}（${schemaCode ?? "?"}）`;
+        }
+        case "listview.create":
+            return `创建列表视图 ${stringArg(args, "name") ?? ""}（${stringArg(args, "code") ?? schemaCode ?? "?"}，模型 ${schemaCode ?? "?"}）`;
+        case "listview.configure": {
+            const codes = Array.isArray(args.fieldCodes) ? args.fieldCodes.map(String).join("、") : "";
+            const sections = ["sorts", "conditions", "actions", "buttons", "presentation", "options", "presentationType", "gantt", "queryLayer", "multiTableHeaderConfig"].filter((key) => args[key] !== undefined);
+            return `配置列表视图 ${stringArg(args, "code") ?? schemaCode ?? "?"}（模型 ${schemaCode ?? "?"}）：列 ${codes || "（未变）"}${sections.length > 0 ? `；同时配置 ${sections.join("、")}` : ""}`;
+        }
+        case "listview.delete":
+            return `删除列表视图 ${stringArg(args, "code") ?? "?"}（${schemaCode ?? "?"}）`;
+        case "app.create":
+            return `创建应用 ${stringArg(args, "name") ?? ""}（${stringArg(args, "code") ?? "?"}）`;
+        case "app.update":
+            return `更新应用 ${stringArg(args, "code") ?? "?"}${stringArg(args, "groupId") ? `（分组 → ${stringArg(args, "groupId")}）` : ""}`;
+        case "app.delete":
+            return `删除应用 ${stringArg(args, "code") ?? "?"}`;
+        default:
+            return `执行 ${tool}`;
+    }
+}
+//# sourceMappingURL=human-summary.js.map

package/dist/identity.js

@@ -0,0 +1,62 @@
+import { ENDPOINTS } from "./endpoints.js";
+import { wireCall, wireRows } from "./wire.js";
+/**
+ * Identity seam (round 10, ergonomics).
+ *
+ * One object carries several names across tools: a model is `schemaCode`, a
+ * field is `code`/`propertyCode`, a business-rule row's wire key is `id` while
+ * its business key is `(schemaCode, ruleCode)`, a workflow is `workflowCode`
+ * while the caller only knows the model's `schemaCode`. Today that forces a
+ * `list → get` dance and per-lane key memorisation.
+ *
+ * These resolvers let a tool accept the BUSINESS key and resolve the wire
+ * identity internally. They are read-only and return `null` for a genuine miss,
+ * so the caller can fail closed with a precise message.
+ */
+/** Resolve a rule ROW id from `(schemaCode, ruleCode)`. Reuses the list face. */
+export async function resolveRuleRowId(session, schemaCode, ruleCode) {
+    const rows = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } })).data);
+    const match = rows.find((row) => row.code === ruleCode);
+    return match?.id !== undefined && match.id !== null && String(match.id) ? String(match.id) : null;
+}
+/**
+ * Resolve a data-rule ROW from `(schemaCode, propertyCode[, dataRuleType])`.
+ * `bizdatarule` rows are keyed physically by `id`; the business locator is the
+ * owning field code (frontend matches `(propertyCodes||[propertyCode])`) plus the
+ * rule type. The caller gets the full row so it can also patch it.
+ */
+export async function resolveDataRuleRow(session, schemaCode, locator) {
+    if (locator.id)
+        return { ok: true, row: { id: locator.id, schemaCode } };
+    const query = { schemaCode };
+    if (locator.dataRuleType !== undefined)
+        query.dataRuleType = String(locator.dataRuleType);
+    const rows = wireRows((await wireCall(session, { path: ENDPOINTS.dataRuleList, query })).data);
+    const wanted = new Set([...(locator.propertyCode ? [locator.propertyCode] : []), ...(locator.propertyCodes ?? [])]);
+    const matches = rows.filter((row) => {
+        const codes = [...(Array.isArray(row.propertyCodes) ? row.propertyCodes.map(String) : []), ...(typeof row.propertyCode === "string" ? [row.propertyCode] : [])];
+        const codeHit = wanted.size === 0 ? true : codes.some((code) => wanted.has(code));
+        const typeHit = locator.dataRuleType === undefined ? true : Number(row.dataRuleType) === locator.dataRuleType;
+        return codeHit && typeHit;
+    });
+    // Ambiguous locator (several rows share the field, e.g. required + readonly):
+    // the caller must disambiguate with dataRuleType, so we refuse rather than
+    // pick one silently.
+    if (matches.length !== 1)
+        return { ok: false, reason: matches.length === 0 ? "absent" : "ambiguous", count: matches.length };
+    return { ok: true, row: matches[0] };
+}
+/**
+ * Resolve the published workflowCode for a model. The platform knows the link
+ * (`workflow/isworkflow` → `workflow/getWorkflow`); the CLI never surfaced it as
+ * a tool, so a caller holding only `schemaCode` was stuck.
+ */
+export async function resolveWorkflowCodeBySchema(session, schemaCode) {
+    const isWorkflow = (await wireCall(session, { path: ENDPOINTS.workflowIsWorkflow, query: { schemaCode } })).data === true;
+    if (!isWorkflow)
+        return null;
+    const template = (await wireCall(session, { path: ENDPOINTS.workflowGetBySchema, query: { schemaCode } })).data;
+    const code = template && typeof template.workflowCode === "string" && template.workflowCode.length > 0 ? template.workflowCode : null;
+    return code;
+}
+//# sourceMappingURL=identity.js.map

package/dist/intent/baseline.js

@@ -0,0 +1,57 @@
+import { resolveModelTreeNode } from "../lanes/model.js";
+import { canonicalJson } from "./dsl.js";
+import { sha256 } from "../support.js";
+import { capabilitiesForModel, orderedCapabilities } from "./capabilities/index.js";
+const absentForm = { present: false, published: false, existDraft: false, boundFieldCodes: [] };
+const absentListview = { present: false, columns: [] };
+/** Read the baseline scope of an intent (its models, fields, default forms). */
+export async function readBaseline(session, intent) {
+    const models = [];
+    const seenTreeModels = new Set();
+    const intentCodes = new Set(intent.models.map((model) => model.code));
+    const capabilities = orderedCapabilities();
+    for (const model of intent.models) {
+        const resolved = await resolveModelTreeNode(session, model.code, undefined);
+        const present = resolved.node !== undefined;
+        for (const row of resolved.treeRows)
+            if (row.type === "BizModel" && typeof row.code === "string")
+                seenTreeModels.add(row.code);
+        const nodeName = typeof resolved.node?.name === "string" && resolved.node.name.length > 0 ? resolved.node.name : null;
+        const draft = { code: model.code, name: nodeName, present, fields: [], form: absentForm, listview: absentListview, rules: [], datarules: [] };
+        // Only read model-scoped capabilities when the model exists. On a real
+        // platform an absent model makes the sub-reads error (bizproperty/list →
+        // 300004 "数据模型不存在！", bizdatarule/list → 601003 "业务模型不存在") and
+        // readBaseline would abort a fresh-model plan; the fake returns empty, which
+        // hid this. Absent model ⇒ nothing to read.
+        if (present)
+            for (const capability of capabilitiesForModel(model))
+                if (capability.read)
+                    await capability.read(session, model, draft);
+        // Omit an empty rules array: a model without declared rules stays
+        // byte-identical to the pre-rule baseline (keeps plans/hashes unchanged).
+        const { rules, datarules, ...rest } = draft;
+        models.push({ ...rest, ...(rules.length > 0 ? { rules } : {}), ...(datarules.length > 0 ? { datarules } : {}) });
+    }
+    const services = [];
+    let reportRows = [];
+    for (const capability of capabilities) {
+        if (!capability.readRoot)
+            continue;
+        const rows = await capability.readRoot(session, intent);
+        if (capability.id === "report")
+            reportRows = rows;
+        else
+            services.push(...rows);
+    }
+    return {
+        models,
+        ...(services.length > 0 ? { services } : {}),
+        ...(reportRows.length > 0 ? { reports: reportRows } : {}),
+        outsideModels: [...seenTreeModels].filter((code) => !intentCodes.has(code)).sort(),
+    };
+}
+/** Stable fingerprint of the baseline scope: any drift changes the hash. */
+export function baselineFingerprintOf(baseline) {
+    return sha256({ scope: "omc-intent-baseline-v1", baseline: JSON.parse(canonicalJson(baseline)) });
+}
+//# sourceMappingURL=baseline.js.map

package/dist/intent/capabilities/bizservice.js

@@ -0,0 +1,274 @@
+import { ENDPOINTS } from "../../endpoints.js";
+import { assertBizServiceAdapterWhitelisted, compileMethodConfigPlain, compileParameterFace, compileServiceConfig, normalizeMethodConfigReadback, normalizeParameterFaceReadback } from "../../bizservice-config.js";
+import { wireCall, wireRows, WireError } from "../../wire.js";
+import { refuse } from "../capability.js";
+import { sameValue } from "../compare.js";
+import { isScalarString, pushError } from "../validation.js";
+import { toPlain } from "../yaml.js";
+import { errorDetail } from "../../tool-types.js";
+const SERVICE_KEYS = new Set(["code", "name", "adapterCode", "serviceCategoryId", "serviceConfig", "method"]);
+const METHOD_KEYS = new Set(["code", "name", "methodConfig", "inputParameters", "outputParameters"]);
+function configError(error) {
+    return errorDetail(error);
+}
+function compileService(service) {
+    assertBizServiceAdapterWhitelisted(service.adapterCode);
+    const serviceConfig = compileServiceConfig(service.adapterCode, service.serviceConfig);
+    if (!service.method)
+        return { serviceConfig };
+    const methodConfig = service.method.methodConfig === undefined ? undefined : compileMethodConfigPlain(service.adapterCode, service.method.methodConfig);
+    const input = service.method.inputParameters === undefined ? undefined : compileParameterFace(service.adapterCode, service.method.inputParameters, "methodInputParameters");
+    const output = service.method.outputParameters === undefined ? undefined : compileParameterFace(service.adapterCode, service.method.outputParameters, "methodOutputParameters");
+    return { serviceConfig, ...(methodConfig !== undefined ? { methodConfig } : {}), ...(input !== undefined ? { input } : {}), ...(output !== undefined ? { output } : {}) };
+}
+function serviceArgs(service) {
+    compileService(service);
+    return {
+        serviceCode: service.code,
+        name: service.name,
+        adapterCode: service.adapterCode,
+        serviceCategoryId: service.serviceCategoryId,
+        serviceConfig: service.serviceConfig,
+        ...(service.method ? {
+            methodName: service.method.code,
+            methodConfig: service.method.methodConfig,
+            ...(service.method.inputParameters ? { methodInputParameters: service.method.inputParameters } : {}),
+            ...(service.method.outputParameters ? { methodOutputParameters: service.method.outputParameters } : {}),
+        } : {}),
+    };
+}
+/**
+ * Expected canonical method config: the intent carries the DECLARED form, but
+ * the write face compiles it (enum→index, RESTFUL connectTime/retryTimes
+ * defaults) and the readback normalizes it back. Projecting the intent through
+ * the SAME compiler + readback normalization makes the drift comparison
+ * apples-to-apples (otherwise compiler-added canonical keys read as drift).
+ */
+function expectedMethodConfig(adapterCode, methodConfig) {
+    if (methodConfig === undefined)
+        return undefined;
+    return normalizeMethodConfigReadback(adapterCode, JSON.parse(compileMethodConfigPlain(adapterCode, methodConfig)));
+}
+/** Expected canonical parameter face: intent → compile → readback-normalize (mirrors the stored row projection). */
+function expectedParameterFace(adapterCode, parameters, label) {
+    if (parameters === undefined)
+        return undefined;
+    return normalizeParameterFaceReadback(adapterCode, JSON.parse(compileParameterFace(adapterCode, parameters, label)));
+}
+function serviceFromRow(service, method, adapterCode) {
+    const decode = (value) => {
+        if (typeof value !== "string")
+            return value;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    };
+    const methodFace = method ? {
+        code: String(method.code ?? ""),
+        present: true,
+        name: typeof method.name === "string" ? method.name : null,
+        methodConfig: normalizeMethodConfigReadback(adapterCode, decode(method.configJson)),
+        inputParameters: normalizeParameterFaceReadback(adapterCode, decode(method.inputParametersJson)),
+        outputParameters: normalizeParameterFaceReadback(adapterCode, decode(method.outputParametersJson)),
+    } : undefined;
+    return {
+        code: String(service?.code ?? ""),
+        present: service !== null,
+        name: typeof service?.name === "string" ? service.name : null,
+        adapterCode: typeof service?.adapterCode === "string" ? service.adapterCode : null,
+        serviceConfig: decode(service?.configJson),
+        ...(methodFace ? { method: methodFace } : {}),
+    };
+}
+function validateServiceNode(serviceNode, index, draft, validation) {
+    const base = `services[${index}]`;
+    for (const entry of serviceNode.entries)
+        if (!SERVICE_KEYS.has(entry.key))
+            pushError(validation, "intent-key-unknown", `service 不支持键 "${entry.key}"`, `${base}.${entry.key}`);
+    const value = (key) => serviceNode.entries.find((entry) => entry.key === key)?.value;
+    const codeNode = value("code");
+    const nameNode = value("name");
+    const adapterNode = value("adapterCode");
+    const categoryNode = value("serviceCategoryId");
+    const configNode = value("serviceConfig");
+    const methodNode = value("method");
+    if (!isScalarString(codeNode) || codeNode.value.trim().length === 0)
+        pushError(validation, "intent-service-code-invalid", "service.code 必须是非空字符串", `${base}.code`, "value");
+    if (!isScalarString(nameNode) || nameNode.value.trim().length === 0)
+        pushError(validation, "intent-service-name-invalid", "service.name 必须是非空字符串", `${base}.name`, "value");
+    if (!isScalarString(adapterNode) || adapterNode.value.trim().length === 0)
+        pushError(validation, "intent-service-adapter-invalid", "service.adapterCode 必须是非空字符串", `${base}.adapterCode`, "value");
+    if (!isScalarString(categoryNode) || categoryNode.value.trim().length === 0)
+        pushError(validation, "intent-service-category-invalid", "service.serviceCategoryId 必须是非空字符串", `${base}.serviceCategoryId`, "value");
+    if (configNode?.kind !== "map")
+        pushError(validation, "intent-service-config-invalid", "service.serviceConfig 必须是映射", `${base}.serviceConfig`, "value");
+    if (methodNode !== undefined && methodNode.kind !== "map")
+        pushError(validation, "intent-service-method-invalid", "service.method 必须是映射", `${base}.method`, "value");
+    if (!isScalarString(codeNode) || !isScalarString(nameNode) || !isScalarString(adapterNode) || !isScalarString(categoryNode) || configNode?.kind !== "map")
+        return;
+    const serviceConfig = toPlain(configNode);
+    let method;
+    try {
+        const methodMap = methodNode?.kind === "map" ? methodNode : undefined;
+        if (methodMap) {
+            for (const entry of methodMap.entries)
+                if (!METHOD_KEYS.has(entry.key))
+                    pushError(validation, "intent-key-unknown", `service.method 不支持键 "${entry.key}"`, `${base}.method.${entry.key}`);
+            const methodValue = (key) => methodMap.entries.find((entry) => entry.key === key)?.value;
+            const methodCode = methodValue("code");
+            const methodName = methodValue("name");
+            const methodConfig = methodValue("methodConfig");
+            const input = methodValue("inputParameters");
+            const output = methodValue("outputParameters");
+            if (!isScalarString(methodCode) || methodCode.value.trim().length === 0)
+                pushError(validation, "intent-method-code-invalid", "service.method.code 必须是非空字符串", `${base}.method.code`, "value");
+            if (!isScalarString(methodName) || methodName.value.trim().length === 0)
+                pushError(validation, "intent-method-name-invalid", "service.method.name 必须是非空字符串", `${base}.method.name`, "value");
+            if (methodConfig !== undefined && methodConfig.kind !== "map")
+                pushError(validation, "intent-method-config-invalid", "service.method.methodConfig 必须是映射", `${base}.method.methodConfig`, "value");
+            if (input !== undefined && input.kind !== "seq")
+                pushError(validation, "intent-method-input-invalid", "service.method.inputParameters 必须是列表", `${base}.method.inputParameters`, "value");
+            if (output !== undefined && output.kind !== "seq")
+                pushError(validation, "intent-method-output-invalid", "service.method.outputParameters 必须是列表", `${base}.method.outputParameters`, "value");
+            if (isScalarString(methodCode) && isScalarString(methodName)) {
+                if (methodCode.value.trim() !== methodName.value.trim())
+                    pushError(validation, "intent-method-name-code-mismatch", "当前 service.register 面 methodName 同时作为方法 code/name；method.name 必须等于 method.code", `${base}.method.name`, "value");
+                method = {
+                    code: methodCode.value.trim(),
+                    name: methodName.value.trim(),
+                    ...(methodConfig?.kind === "map" ? { methodConfig: toPlain(methodConfig) } : {}),
+                    ...(input?.kind === "seq" ? { inputParameters: input.items.map((item) => toPlain(item)) } : {}),
+                    ...(output?.kind === "seq" ? { outputParameters: output.items.map((item) => toPlain(item)) } : {}),
+                };
+            }
+        }
+        compileService({ code: codeNode.value.trim(), name: nameNode.value.trim(), adapterCode: adapterNode.value.trim(), serviceCategoryId: categoryNode.value.trim(), serviceConfig, ...(method ? { method } : {}) });
+    }
+    catch (error) {
+        pushError(validation, "intent-service-config-unsupported", configError(error), base, "value");
+        return;
+    }
+    draft.services.push({ code: codeNode.value.trim(), name: nameNode.value.trim(), adapterCode: adapterNode.value.trim(), serviceCategoryId: categoryNode.value.trim(), serviceConfig, ...(method ? { method } : {}) });
+}
+export const bizserviceCapability = {
+    id: "bizservice",
+    title: "业务集成",
+    requires: [],
+    operations: ["register"],
+    validateRoot(tree, draft, validation) {
+        const servicesNode = tree.entries.find((entry) => entry.key === "services")?.value;
+        if (servicesNode === undefined || (servicesNode.kind === "scalar" && servicesNode.value === null))
+            return;
+        if (servicesNode.kind !== "seq") {
+            pushError(validation, "intent-services-not-a-list", "services 必须是列表", "services", "value");
+            return;
+        }
+        const seen = new Set();
+        servicesNode.items.forEach((node, index) => {
+            if (node.kind !== "map") {
+                pushError(validation, "intent-service-not-a-map", "service 必须是映射", `services[${index}]`, "value");
+                return;
+            }
+            const before = draft.services.length;
+            validateServiceNode(node, index, draft, validation);
+            const added = draft.services[before];
+            if (added && seen.has(added.code))
+                pushError(validation, "intent-service-code-duplicate", `service code 重复：${added.code}`, `services[${index}].code`, "value");
+            if (added)
+                seen.add(added.code);
+        });
+    },
+    async readRoot(session, intent) {
+        const services = intent.services ?? [];
+        const result = [];
+        for (const service of services) {
+            let row = null;
+            try {
+                row = (await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: service.code } })).data;
+            }
+            catch (error) {
+                if (!(error instanceof WireError && error.kind === "business" && error.errcode === 500001))
+                    throw error;
+            }
+            if (!row) {
+                result.push({ code: service.code, present: false, name: null, adapterCode: null });
+                continue;
+            }
+            let method;
+            if (service.method) {
+                const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: service.code, filterFlag: "false" } })).data);
+                method = rows.find((candidate) => candidate.code === service.method.code);
+            }
+            result.push(serviceFromRow(row, method, String(row.adapterCode ?? service.adapterCode)));
+        }
+        return result;
+    },
+    planRoot(intent, baseline, emit) {
+        const services = intent.services ?? [];
+        const current = baseline.services ?? [];
+        for (const service of services) {
+            const live = current.find((entry) => entry.code === service.code);
+            const args = serviceArgs(service);
+            const resource = `service:${service.code}`;
+            if (!live?.present) {
+                emit.change("service.register", args, resource, "service-absent");
+                continue;
+            }
+            // An existing service is patched, not recreated. adapterCode is fixed at
+            // creation (the update face derives it from the stored row), so a declared
+            // adapter change is a genuine refusal.
+            if (live.adapterCode !== service.adapterCode)
+                refuse("intent-service-adapter-immutable", `业务服务 ${service.code} 的 adapterCode 已固定为 ${live.adapterCode ?? "(未知)"}，意图声明 ${service.adapterCode}——adapter 创建后不可迁移；修正意图或走 omc call`, { resource });
+            if (live.name !== service.name || !sameValue(live.serviceConfig, service.serviceConfig))
+                emit.change("service.update", { serviceCode: service.code, name: service.name, serviceConfig: service.serviceConfig }, resource, "service-drift");
+            else
+                emit.skip(resource, "service-present");
+            if (!service.method)
+                continue;
+            const methodResource = `method:${service.code}.${service.method.code}`;
+            if (!live.method?.present)
+                // The low-level face has method.update/delete but no method.create, and
+                // method.update refuses an absent method — adding a method to an
+                // existing service has no declarative tool. Refuse with the path.
+                refuse("intent-method-create-unsupported", `业务服务 ${service.code} 已存在但没有方法 ${service.method.code}；当前面没有声明式“加方法”能力（method.update 要求方法已存在）。删除服务后重建，或走 omc call`, { resource: methodResource });
+            if (live.method.name !== service.method.name || !sameValue(live.method.methodConfig, expectedMethodConfig(service.adapterCode, service.method.methodConfig)) || !sameValue(live.method.inputParameters, expectedParameterFace(service.adapterCode, service.method.inputParameters, "methodInputParameters")) || !sameValue(live.method.outputParameters, expectedParameterFace(service.adapterCode, service.method.outputParameters, "methodOutputParameters")))
+                emit.change("method.update", {
+                    serviceCode: service.code,
+                    methodCode: service.method.code,
+                    name: service.method.name,
+                    ...(service.method.methodConfig !== undefined ? { methodConfig: service.method.methodConfig } : {}),
+                    ...(service.method.inputParameters !== undefined ? { methodInputParameters: service.method.inputParameters } : {}),
+                    ...(service.method.outputParameters !== undefined ? { methodOutputParameters: service.method.outputParameters } : {}),
+                }, methodResource, "method-drift");
+            else
+                emit.skip(methodResource, "method-present");
+        }
+    },
+    decodeRoot(baseline, live) {
+        if (baseline.services !== undefined)
+            live.services = baseline.services.map((service) => ({ ...service }));
+    },
+    compareRoot(intent, live, emit) {
+        for (const service of intent.services ?? []) {
+            const current = live.services?.find((entry) => entry.code === service.code);
+            const resource = `service:${service.code}`;
+            if (!current?.present) {
+                emit.difference("service-missing", resource, `业务服务 ${service.code} 不存在`);
+                continue;
+            }
+            if (current.name !== service.name || current.adapterCode !== service.adapterCode || !sameValue(current.serviceConfig, service.serviceConfig))
+                emit.difference("service-mismatch", resource, `业务服务 ${service.code} 的名称/适配器/configJson 不等价`);
+            if (service.method) {
+                const method = current.method;
+                if (!method?.present)
+                    emit.difference("method-missing", `method:${service.code}.${service.method.code}`, `业务方法 ${service.code}/${service.method.code} 不存在`);
+                else if (method.name !== service.method.name || !sameValue(method.methodConfig, expectedMethodConfig(service.adapterCode, service.method.methodConfig)) || !sameValue(method.inputParameters, expectedParameterFace(service.adapterCode, service.method.inputParameters, "methodInputParameters")) || !sameValue(method.outputParameters, expectedParameterFace(service.adapterCode, service.method.outputParameters, "methodOutputParameters")))
+                    emit.difference("method-mismatch", `method:${service.code}.${service.method.code}`, `业务方法 ${service.code}/${service.method.code} 不等价`);
+            }
+        }
+    },
+};
+//# sourceMappingURL=bizservice.js.map