@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/intent/compiler.js

@@ -0,0 +1,79 @@
+import { capabilitiesForModel, orderedCapabilities } from "./capabilities/index.js";
+const absentForm = { present: false, published: false, existDraft: false, boundFieldCodes: [] };
+const absentListview = { present: false, columns: [] };
+/** A model the baseline did not cover still plans as fully absent (defensive). */
+function absentModel(code) {
+    return { code, name: null, present: false, fields: [], form: absentForm, listview: absentListview };
+}
+/**
+ * Compile an intent against its baseline into ordered changes + skips.
+ *
+ * Ordering is CAPABILITY-major: for each capability in dependency order, plan
+ * every model. This is what makes declared `requires` hold ACROSS models — a
+ * rule on model A that references model B's fields needs every model's fields
+ * published before any rule is planned. (Single-model intents are unaffected;
+ * multi-model intents order by capability instead of by model, which is the
+ * correct dependency order.) The emitted arrays are local, so a refusal thrown
+ * mid-compile is never observable.
+ */
+export function compileIntent(intent, baseline) {
+    const changes = [];
+    const skipped = [];
+    const capabilities = orderedCapabilities();
+    const emit = {
+        change: (tool, args, resource, reason) => changes.push({ tool, args, resource, reason }),
+        skip: (resource, reason) => skipped.push({ resource, reason }),
+    };
+    const stateOf = (code) => baseline.models.find((entry) => entry.code === code) ?? absentModel(code);
+    // A declared-absent model only ever plans its own deletion, so restrict it to
+    // the model capability while keeping capability-major ordering.
+    const activeIds = new Map(intent.models.map((model) => [model.code, new Set(capabilitiesForModel(model).map((capability) => capability.id))]));
+    for (const capability of capabilities) {
+        capability.planRoot?.(intent, baseline, emit);
+        for (const model of intent.models)
+            if (activeIds.get(model.code).has(capability.id))
+                capability.plan?.(model, stateOf(model.code), emit);
+    }
+    const expectedReadback = intent.models.map((model) => {
+        const requestedCodes = model.fields.filter((field) => field.absent !== true).map((field) => field.code);
+        const wantsForm = model.form?.publish === true;
+        const formFieldCodes = model.form?.fieldCodes ?? requestedCodes;
+        return {
+            model: model.code,
+            publishedFieldCodes: requestedCodes,
+            formPublished: wantsForm,
+            frontend: { formBoundFieldCodes: wantsForm ? formFieldCodes : [], listviewColumns: model.listview?.fieldCodes ?? [] },
+            ...(model.rules?.length ? { rules: model.rules.map((rule) => ({ code: rule.code, enabled: rule.enabled })) } : {}),
+            ...(model.datarules?.some((rule) => rule.absent !== true) ? { datarules: model.datarules.filter((rule) => rule.absent !== true).map((rule) => ({ propertyCode: rule.propertyCode, dataRuleType: rule.dataRuleType })) } : {}),
+            ...(model.workflow ? { workflow: { code: model.workflow.code, published: model.workflow.publish } } : {}),
+            ...(model.onlinejs ? { onlinejs: { published: model.onlinejs.publish } } : {}),
+        };
+    });
+    const expectedServices = (intent.services ?? []).map((service) => ({
+        service: service.code,
+        adapterCode: service.adapterCode,
+        ...(service.method ? { methodCode: service.method.code } : {}),
+    }));
+    const expectedReports = (intent.reports ?? []).map((report) => ({
+        report: report.code,
+        appCode: report.appCode,
+        chartUuids: (report.charts ?? []).map((chart) => chart.uuid),
+    }));
+    const tools = new Set(changes.map((change) => change.tool));
+    // Spec 107 story 10: destructive changes are explicitly marked. Any `*.delete`
+    // is destructive and wins over the lifecycle/additive classification.
+    const deletes = changes.filter((change) => change.tool.endsWith(".delete"));
+    const riskClass = changes.length === 0
+        ? "none"
+        : deletes.length > 0
+            ? "destructive"
+            : tools.has("form.publish") || tools.has("form.draft") || tools.has("field.publish") || tools.has("rule.enable") || tools.has("workflow.publish") || tools.has("onlinejs.compose")
+                ? "lifecycle"
+                : "additive";
+    // The plan's cleanup list makes every declared deletion visible before
+    // approval. It only ever names resources the intent explicitly declared
+    // absent — the ensure-present ownership boundary is unchanged.
+    const cleanup = deletes.map((change) => ({ resource: change.resource, action: change.tool }));
+    return { changes, skipped, riskClass, expectedReadback, expectedServices, expectedReports, cleanup };
+}
+//# sourceMappingURL=compiler.js.map

package/dist/intent/dsl.js

@@ -0,0 +1,129 @@
+import { capabilitiesForModel, orderedCapabilities } from "./capabilities/index.js";
+import { describe, makeValidation, pushError } from "./validation.js";
+import { parseYaml, toPlain, YamlSyntaxError } from "./yaml.js";
+/**
+ * Ticket 117 — the declarative intent DSL (v1) and its offline semantic
+ * validation. The DSL expresses business intent for the Configuration
+ * capabilities the intent face supports; it deliberately does NOT speak wire
+ * shapes — the capabilities own DTO defaults, ordering, and lifecycle.
+ *
+ * Ticket 124 — the assembler is now a thin registry walk: it owns the root
+ * shape (intentVersion / models) and hands each model node to every
+ * Configuration capability (src/intent/capabilities) for its slice. Adding a
+ * capability no longer edits this file.
+ *
+ * Every validation error carries the source location of the offending key
+ * so an agent can fix the file without guessing.
+ */
+export const INTENT_VERSION = 1;
+export class IntentInvalidError extends Error {
+    errors;
+    constructor(errors) {
+        super(errors[0]?.message ?? "intent invalid");
+        this.errors = errors;
+    }
+}
+/** Validate a located YAML tree against the intent DSL v1; returns the normalized intent or throws. */
+export function validateIntentTree(tree) {
+    const validation = makeValidation(tree);
+    if (tree.kind !== "map") {
+        pushError(validation, "intent-root-not-a-map", "intent 文件顶层必须是映射（intentVersion / models）", "", "value");
+        throw new IntentInvalidError(validation.errors);
+    }
+    const entryOf = (key) => tree.entries.find((entry) => entry.key === key)?.value;
+    for (const entry of tree.entries) {
+        if (!["intentVersion", "models", "services", "reports"].includes(entry.key))
+            pushError(validation, "intent-key-unknown", `顶层不支持键 "${entry.key}"（只接受 intentVersion / models / services / reports）`, entry.key);
+    }
+    const versionNode = entryOf("intentVersion");
+    if (versionNode === undefined) {
+        pushError(validation, "intent-version-missing", "缺少 intentVersion（当前支持 1）", "models", "value");
+    }
+    else if (versionNode.kind !== "scalar" || typeof versionNode.value !== "number" || versionNode.value !== INTENT_VERSION) {
+        pushError(validation, "intent-version-unsupported", `intentVersion 必须是 ${INTENT_VERSION}（得到 ${describe(versionNode)}）`, "intentVersion", "value");
+        throw new IntentInvalidError(validation.errors);
+    }
+    const rootDraft = { services: [], reports: [] };
+    const capabilities = orderedCapabilities();
+    for (const capability of capabilities)
+        capability.validateRoot?.(tree, rootDraft, validation);
+    const modelsNode = entryOf("models");
+    const hasRootResources = rootDraft.services.length > 0 || rootDraft.reports.length > 0;
+    if (modelsNode === undefined) {
+        // Ticket 128/r1-report: a root-only intent (services[]/reports[]) is valid;
+        // models[] is required only when the intent carries no root-scoped resource.
+        if (!hasRootResources)
+            pushError(validation, "intent-models-missing", "缺少 models（至少声明一个模型；或声明 services / reports）", "models", "value");
+        if (validation.errors.length > 0)
+            throw new IntentInvalidError(validation.errors);
+        return { intentVersion: INTENT_VERSION, models: [], ...(rootDraft.services.length > 0 ? { services: rootDraft.services } : {}), ...(rootDraft.reports.length > 0 ? { reports: rootDraft.reports } : {}) };
+    }
+    if (modelsNode.kind !== "seq") {
+        pushError(validation, "intent-models-not-a-list", `models 必须是列表（得到 ${describe(modelsNode)}）`, "models", "value");
+        throw new IntentInvalidError(validation.errors);
+    }
+    if (modelsNode.items.length === 0) {
+        pushError(validation, "intent-models-empty", "models 不能为空——空意图没有可交付内容", "models", "value");
+        throw new IntentInvalidError(validation.errors);
+    }
+    const seenModelCodes = new Set();
+    const models = [];
+    modelsNode.items.forEach((modelNode, modelIndex) => {
+        const base = `models[${modelIndex}]`;
+        if (modelNode.kind !== "map") {
+            pushError(validation, "intent-model-not-a-map", `模型项必须是映射（得到 ${describe(modelNode)}）`, base, "value");
+            return;
+        }
+        const draft = { code: "", name: "", identityValid: false, fields: [], rules: [], datarules: [] };
+        const ctx = { ...validation, base, seenModelCodes };
+        // A declared-absent model is a deletion target: validate only the model
+        // capability, so a stray shape key is refused once (by the model capability)
+        // without a cascade of field/form errors.
+        const absentNode = modelNode.entries.find((entry) => entry.key === "absent")?.value;
+        const absentFlag = absentNode?.kind === "scalar" && absentNode.value === true;
+        for (const capability of capabilitiesForModel({ absent: absentFlag }))
+            capability.validate?.(modelNode, draft, ctx);
+        if (!draft.identityValid)
+            return;
+        models.push({
+            code: draft.code,
+            name: draft.name,
+            ...(draft.absent ? { absent: true } : {}),
+            fields: draft.fields,
+            ...(draft.form ? { form: draft.form } : {}),
+            ...(draft.listview ? { listview: draft.listview } : {}),
+            ...(draft.rules.length > 0 ? { rules: draft.rules } : {}),
+            ...(draft.datarules.length > 0 ? { datarules: draft.datarules } : {}),
+            ...(draft.workflow ? { workflow: draft.workflow } : {}),
+            ...(draft.onlinejs ? { onlinejs: draft.onlinejs } : {}),
+        });
+    });
+    if (validation.errors.length > 0)
+        throw new IntentInvalidError(validation.errors);
+    return { intentVersion: INTENT_VERSION, models, ...(rootDraft.services.length > 0 ? { services: rootDraft.services } : {}), ...(rootDraft.reports.length > 0 ? { reports: rootDraft.reports } : {}) };
+}
+/** Parse + validate an intent YAML document (offline, zero environment contact). */
+export function parseIntent(text) {
+    const tree = parseYaml(text);
+    const intent = validateIntentTree(tree);
+    return { intent, tree };
+}
+/** Canonical JSON (sorted keys) — the deterministic serialization for hashes. */
+export function canonicalJson(value) {
+    return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entry]) => [key, sortValue(entry)]));
+    return value;
+}
+/** The plain (position-free) value of a parsed intent tree — used by tests and fixtures. */
+export function plainOf(tree) {
+    return toPlain(tree);
+}
+export { YamlSyntaxError };
+//# sourceMappingURL=dsl.js.map

package/dist/intent/plan-file.js

@@ -0,0 +1,63 @@
+import { sha256 } from "../support.js";
+import { canonicalJson } from "./dsl.js";
+import { baselineFingerprintOf } from "./baseline.js";
+/**
+ * Ticket 118 — the immutable intent plan: the approval object of the
+ * declarative face (Spec 107). It pins environment identity, the baseline
+ * fingerprint it was computed against, the intent hash, and the exact
+ * changes. planHash covers EVERYTHING (canonical JSON, no timestamps) so
+ * what a human approves is byte-verifiable at apply time (ticket 119): the
+ * planHash IS the approval anchor.
+ */
+export const INTENT_PLAN_SCHEMA = "omc-intent-plan-v1";
+export function intentHashOf(intent) {
+    return sha256({ scope: "omc-intent-v1", intent: JSON.parse(canonicalJson(intent)) });
+}
+/** Compute the plan's hash over everything except the hash itself. */
+export function planHashOf(plan) {
+    return sha256({ scope: INTENT_PLAN_SCHEMA, plan: JSON.parse(canonicalJson(plan)) });
+}
+export function buildPlan(input) {
+    const plan = {
+        schema: INTENT_PLAN_SCHEMA,
+        intentVersion: input.intent.intentVersion,
+        compiler: input.compiler,
+        environment: input.environment,
+        environmentFingerprint: input.environmentFingerprint,
+        baselineFingerprint: baselineFingerprintOf(input.baseline),
+        baseline: input.baseline,
+        intent: input.intent,
+        intentHash: intentHashOf(input.intent),
+        changes: input.compiled.changes,
+        skipped: input.compiled.skipped,
+        riskClass: input.compiled.riskClass,
+        expectedReadback: input.compiled.expectedReadback,
+        cleanup: input.compiled.cleanup,
+        ...(input.compiled.expectedServices.length > 0 ? { expectedServices: input.compiled.expectedServices } : {}),
+        ...(input.compiled.expectedReports.length > 0 ? { expectedReports: input.compiled.expectedReports } : {}),
+    };
+    return { ...plan, planHash: planHashOf(plan) };
+}
+/** Structural check + hash re-verification of a parsed plan file. */
+export function verifyPlan(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return { ok: false, code: "intent-plan-invalid", reason: "plan 文件必须是 JSON 对象" };
+    const plan = value;
+    if (plan.schema !== INTENT_PLAN_SCHEMA)
+        return { ok: false, code: "intent-plan-invalid", reason: `plan.schema 必须是 ${INTENT_PLAN_SCHEMA}` };
+    const required = ["intentVersion", "compiler", "environment", "environmentFingerprint", "baselineFingerprint", "baseline", "intent", "intentHash", "changes", "skipped", "riskClass", "expectedReadback", "cleanup", "planHash"];
+    for (const key of required) {
+        if (plan[key] === undefined)
+            return { ok: false, code: "intent-plan-invalid", reason: `plan 缺少必填字段 ${key}` };
+    }
+    if (!Array.isArray(plan.changes) || plan.changes.some((change) => typeof change?.tool !== "string"))
+        return { ok: false, code: "intent-plan-invalid", reason: "plan.changes 必须是 {tool,args,resource,reason} 数组" };
+    if (typeof plan.planHash !== "string" || plan.planHash.length !== 64)
+        return { ok: false, code: "intent-plan-invalid", reason: "plan.planHash 必须是 64 位 sha256" };
+    const { planHash, ...rest } = plan;
+    const recomputed = planHashOf(rest);
+    if (recomputed !== planHash)
+        return { ok: false, code: "intent-plan-tampered", reason: "plan 哈希不匹配：文件内容与生成时不一致（what you approve must be byte-identical to what executes）" };
+    return { ok: true, plan: plan };
+}
+//# sourceMappingURL=plan-file.js.map

package/dist/intent/readback.js

@@ -0,0 +1,65 @@
+import { capabilitiesForModel, orderedCapabilities } from "./capabilities/index.js";
+const absentForm = { present: false, published: false, existDraft: false, boundFieldCodes: [] };
+/** Fresh per model: form/listview decoders write into the frontend in place. */
+const newFrontend = () => ({ formBoundFieldCodes: [], listviewPresent: false, listviewColumns: [] });
+/** A model the live read did not cover still compares as fully absent (defensive). */
+function absentLiveModel(code) {
+    return { code, name: null, present: false, fields: [], form: absentForm, frontend: newFrontend() };
+}
+/**
+ * Decode a baseline into the intent shape (wire ints -> family names). The
+ * optional `intent` lets a declared-absent model run ONLY the model capability,
+ * mirroring compare (a baseline alone cannot know which models are deleted).
+ */
+export function decodeBaseline(baseline, intent) {
+    const absentCodes = new Set((intent?.models ?? []).filter((model) => model.absent === true).map((model) => model.code));
+    const live = {
+        models: baseline.models.map((model) => {
+            const draft = {
+                code: model.code,
+                name: model.name,
+                present: model.present,
+                fields: [],
+                form: absentForm,
+                frontend: newFrontend(),
+                rules: [],
+                datarules: [],
+            };
+            for (const capability of capabilitiesForModel({ absent: absentCodes.has(model.code) }))
+                capability.decode?.(model, draft);
+            const { rules, datarules, ...rest } = draft;
+            return { ...rest, ...(rules.length > 0 ? { rules } : {}), ...(datarules.length > 0 ? { datarules } : {}) };
+        }),
+        outsideModels: baseline.outsideModels,
+    };
+    for (const capability of orderedCapabilities())
+        capability.decodeRoot?.(baseline, live);
+    return live;
+}
+/** Compare the source intent with the decoded live state. */
+export function compareWithLive(intent, live) {
+    const differences = [];
+    const ignored = [];
+    const emit = {
+        difference: (kind, resource, message) => differences.push({ kind, resource, message }),
+        ignored: (resource) => ignored.push(resource),
+    };
+    const capabilities = orderedCapabilities();
+    const liveModels = new Map(live.models.map((model) => [model.code, model]));
+    for (const model of intent.models) {
+        const state = liveModels.get(model.code) ?? absentLiveModel(model.code);
+        // A declared-absent model compares only its own presence.
+        for (const capability of capabilitiesForModel(model))
+            capability.compare?.(model, state, emit);
+    }
+    for (const capability of capabilities)
+        capability.compareRoot?.(intent, live, emit);
+    const intentModelCodes = new Set(intent.models.map((model) => model.code));
+    for (const state of live.models)
+        if (!intentModelCodes.has(state.code))
+            ignored.push(`model:${state.code}`);
+    for (const code of live.outsideModels)
+        ignored.push(`model:${code}`);
+    return { equivalent: differences.length === 0, differences, ignoredOutsideIntent: ignored };
+}
+//# sourceMappingURL=readback.js.map

package/dist/intent/schema.js

@@ -0,0 +1,158 @@
+/**
+ * P0 friction fix (3-round dogfood 2026-09-29): the intent YAML had no
+ * authoritative discovery face — `omc intent --help` lists four subcommands and
+ * `omc describe intent` did not exist, so callers had to reconstruct the key set,
+ * the comparison operators, the choice-family shape and the relation shape from
+ * prose + `validate` trial-and-error. This module is that face: one offline
+ * projection of the DSL (key names, allowed values, operators, runnable
+ * examples) reachable as `omc intent schema` and `omc describe intent`.
+ *
+ * It is a projection, not a second source of truth: key sets are imported from
+ * the capability validators so they cannot drift.
+ */
+/** Comparison operators accepted by `actions[].when` (execution gate) and `actions[].filter` (row locator). */
+export const INTENT_CONDITION_OPERATORS = Object.freeze({
+    equals: "EQ (equal)",
+    notEquals: "NEQ (not equal)",
+    gt: "GT (greater than)",
+    gte: "GTEQ (greater than or equal)",
+    lt: "LT (less than)",
+    lte: "LTEQ (less than or equal)",
+    from: "dynamic — compare against another FIELD: `from: <fieldCode>` (equivalent to equals a field; only for `filter`)",
+});
+/** A `when` gate leaf compares against a literal; `from` (field-to-field) is only for `filter`. */
+export const INTENT_WHEN_OPERATORS = Object.freeze(["equals", "notEquals", "gt", "gte", "lt", "lte"]);
+const RUNNABLE_EXAMPLES = Object.freeze([
+    {
+        id: "scalar-numeric-radio",
+        title: "标量/数值/RADIO（choices）——type 用族名，NUMERICAL 必带 options.scale，选择族用顶层 choices",
+        yaml: [
+            "intentVersion: 1",
+            "models:",
+            "  - code: ex_order",
+            "    name: 订单",
+            "    fields:",
+            "      - { code: order_no, name: 订单号, type: SHORT_TEXT }",
+            "      - { code: amount, name: 金额, type: NUMERICAL, options: { scale: 2 } }",
+            "      - { code: level, name: 等级, type: RADIO, choices: [A, B, C] }  # choices 只用于 RADIO/CHECKBOX/DROPDOWN_BOX/DROPDOWN_MULTI_BOX",
+            "    form: { publish: true }",
+            "    listview: { fieldCodes: [order_no, amount, level] }",
+            "",
+        ].join("\n"),
+    },
+    {
+        id: "relation-work-sheet",
+        title: "关联字段 WORK_SHEET（relativeCode 指向目标模型，displayField 用 options；`mappings` 在原始 field.create 面是空字符串）",
+        yaml: [
+            "intentVersion: 1",
+            "models:",
+            "  - code: ex_supplier",
+            "    name: 供应商",
+            "    fields:",
+            "      - { code: sup_name, name: 名称, type: SHORT_TEXT }",
+            "    form: { publish: true }",
+            "  - code: ex_contract",
+            "    name: 合同",
+            "    fields:",
+            "      - code: supplier",
+            "        name: 供应商",
+            "        type: WORK_SHEET",
+            "        relativeCode: ex_supplier          # 目标模型 code",
+            "        options: { displayField: sup_name }  # 显示字段",
+            "    form: { publish: true }",
+            "",
+        ].join("\n"),
+    },
+    {
+        id: "rule-actions-when-filter",
+        title: "规则紧凑 actions：一条规则可挂多个异构 action；when=执行门(满足才执行，只支持字面量比较)，filter=定位要改的行（省略则默认当前行 id=id），跨模型回写用 filter from",
+        yaml: [
+            "intentVersion: 1",
+            "models:",
+            "  - code: ex_order",
+            "    name: 订单",
+            "    fields:",
+            "      - { code: amount, name: 金额, type: NUMERICAL, options: { scale: 2 } }",
+            "      - { code: status, name: 状态, type: SHORT_TEXT }",
+            "      - { code: supplier, name: 供应商, type: WORK_SHEET, relativeCode: ex_supplier }",
+            "    rules:",
+            "      - code: Create",
+            "        name: 新增分级",
+            "        enabled: true",
+            "        actions:",
+            "          # 同一规则内多个 action：按数组顺序编译为串行节点",
+            "          - type: UPDATE",
+            "            target: ex_order",
+            "            when: [{ field: amount, gte: 100000 }]   # 执行门：满足才执行（gte/lte 合法）",
+            "            set: [{ field: status, value: 大额 }]     # 省略 filter -> 只改当前记录",
+            "          - type: UPDATE",
+            "            target: ex_order",
+            "            when: [{ field: amount, lt: 100000 }]",
+            "            set: [{ field: status, value: 小额 }]",
+            "          - type: UPDATE",
+            "            target: ex_supplier                        # 跨模型回写",
+            "            filter: [{ field: id, from: supplier }]    # 定位目标行：目标 id = 当前记录的 supplier",
+            "            set: [{ field: total_amount, from: amount }]",
+            "",
+        ].join("\n"),
+    },
+]);
+/**
+ * The intent-face DSL schema (offline). Key sets mirror the validators; this is
+ * what `omc intent schema` / `omc describe intent` return.
+ */
+export function intentSchemaBlock() {
+    return {
+        status: "ok",
+        intentVersion: 1,
+        topLevel: { required: ["intentVersion", "models"], optional: ["services"], note: "intentVersion 必须是 1" },
+        models: {
+            required: ["code", "fields"],
+            optional: ["name", "absent", "form", "listview", "rules", "datarules", "workflow", "onlinejs"],
+            absent: "absent:true 删除整个模型（riskClass=destructive）；显式缺席是唯一删除语义",
+        },
+        fields: {
+            required: ["code（顶层；子列同为 code）", "type（字段族名）"],
+            optional: ["name", "choices", "subFields", "options", "relativeCode", "displayField", "absent"],
+            notes: [
+                "type 用字段族名（见 fieldFamilies）；NUMERICAL 必带 options.scale",
+                "choices 只用于选择族 RADIO / CHECKBOX / DROPDOWN_BOX / DROPDOWN_MULTI_BOX（顶层 choices，不是 options.items/choices）",
+                "WORK_SHEET / MULT_WORK_SHEET 用顶层 relativeCode=<目标模型 code>；显示列用 options.displayField",
+                "CHILD_TABLE 用 subFields[{code,name,type[,choices]}]; 子列族仅标量",
+                "门户层条件（必填/只读/显示）写在 options：options.requiredFormula / readonlyFormula / readonlyCondition / displayFormula",
+            ],
+        },
+        form: { required: ["publish"], optional: ["fieldCodes"] },
+        listview: { required: [], optional: ["code", "name", "fieldCodes", "absent"], note: "intent 只声明列；业务筛选/排序/按钮 apply 后用 omc call listview.configure 补" },
+        datarules: { required: ["propertyCode", "dataRuleType"], optional: ["options", "checkType", "childRule", "name", "sortKey", "absent"], note: "type3/4/5 不驱动门户；门户条件走 fields[].options" },
+        rules: {
+            required: ["code", "name", "enabled"],
+            optional: ["bizRuleType", "customTrigger", "actions", "nodeGraph"],
+            note: "actions（紧凑 UPDATE）与 nodeGraph 二选一；非 UPDATE 节点用 nodeGraph",
+            actionLeaf: {
+                type: "UPDATE（目前唯一）",
+                target: "目标模型 code（省略=当前模型）",
+                when: "执行门 dataCondition：[{field, <op>: <literal>}]，op ∈ " + INTENT_WHEN_OPERATORS.join("/"),
+                filter: "定位 filterCondition：[{field, <op>: <literal>}] 或 [{field, from: <当前字段>}]；省略=只改当前行(id=id)",
+                set: "[{field, value: <literal>} | {field, from: <当前字段>}]",
+            },
+        },
+        conditionOperators: INTENT_CONDITION_OPERATORS,
+        workflow: { required: ["code", "name", "publish"], optional: ["template", "bindRules"], note: "bindRules [{handler: start|cancel|activate|end, ruleCodes:[...]}]；流程事件只绑自定义规则" },
+        onlinejs: { required: ["source", "publish"], optional: ["sheetCode", "replace"], note: "replace:true 覆盖；merge 时 source 只给生命周期片段，不能是完整 (function(form){...})" },
+        services: { required: ["code", "name", "adapterCode", "serviceCategoryId", "serviceConfig"], optional: ["method"], note: "自定义/INTERNAL 适配器走二开扩展包导入，不在声明式写面" },
+        examples: RUNNABLE_EXAMPLES.map((example) => ({ id: example.id, title: example.title })),
+        exampleHint: "取可运行 YAML：omc describe intent --example <id>",
+        versionNotice: "intent 只覆盖声明式子集（capabilities 的 intent: partial）；未覆盖面用 omc call 补齐。",
+    };
+}
+/** A single runnable example for `describe intent --example <id>`. */
+export function intentExample(id) {
+    const example = RUNNABLE_EXAMPLES.find((entry) => entry.id === id);
+    return example ? { status: "ok", id: example.id, title: example.title, yaml: example.yaml } : undefined;
+}
+/** All example ids (for near-miss hints). */
+export function intentExampleIds() {
+    return RUNNABLE_EXAMPLES.map((example) => example.id);
+}
+//# sourceMappingURL=schema.js.map

package/dist/intent/validation.js

@@ -0,0 +1,30 @@
+import { locateKey, nodeAt } from "./yaml.js";
+export function makeValidation(tree) {
+    const errors = [];
+    const fallback = { line: 1, column: 1 };
+    return {
+        errors,
+        locateKey: (path) => locateKey(tree, path) ?? fallback,
+        locateValue: (path) => {
+            const node = nodeAt(tree, path);
+            return node === undefined ? (locateKey(tree, path) ?? fallback) : { line: node.line, column: node.column };
+        },
+    };
+}
+export function pushError(validation, code, message, path, pointer = "key", extra) {
+    const located = pointer === "key" ? validation.locateKey(path) : validation.locateValue(path);
+    validation.errors.push({ code, message, path, line: located.line, column: located.column, ...(extra?.validation ? { validation: extra.validation } : {}) });
+}
+export const isScalarString = (node) => node !== undefined && node.kind === "scalar" && typeof node.value === "string" && node.value.length > 0;
+export function describe(node) {
+    if (node === undefined)
+        return "缺失";
+    if (node.kind === "map")
+        return "映射";
+    if (node.kind === "seq")
+        return "列表";
+    if (node.value === null)
+        return "null";
+    return `"${String(node.value)}"（${typeof node.value}）`;
+}
+//# sourceMappingURL=validation.js.map