@stalfh233/omc-cli 0.5.16 → 0.6.0

package/dist/lanes/programming.js

@@ -0,0 +1,435 @@
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { ENDPOINTS } from "../endpoints.js";
+import { capabilityArg, environmentArg } from "../args.js";
+import { governedRead } from "../read.js";
+import { writeTool } from "../write.js";
+import { defineTool, ToolRefusalError } from "../tool-types.js";
+import { wireCall, WireError } from "../wire.js";
+import { PROGRAMMING_LANE_CONTRACT, PROGRAMMING_WIRE } from "./programming-contract.js";
+const LANE = PROGRAMMING_LANE_CONTRACT.lane;
+const TOOLS = PROGRAMMING_LANE_CONTRACT.tools;
+/** metadata.app.CodeType is the NUMERIC index on the wire (8.6.26 source). */
+const CODE_TYPE_BUSINESS_RULE = 0;
+/**
+ * Template packages the platform itself generates. 8.6.26 source + the official
+ * dev guide say `...engine.service.bizrule.handler`; the live AI-Platform
+ * v1.1.25 (8.7-era) deployment generates `...engine.sourcecode.handler`
+ * (live smoke 2026-11-03, `programming.get test/Create`). The guard must accept
+ * any package the platform emits — refusing the platform's own template is the
+ * one false positive that makes the whole lane unusable on a newer build.
+ */
+const TEMPLATE_PACKAGES = new Set([
+    "com.authine.cloudpivot.engine.service.bizrule.handler",
+    "com.authine.cloudpivot.engine.sourcecode.handler",
+]);
+const TEMPLATE_PACKAGE_HINT = [...TEMPLATE_PACKAGES].join(" 或 ");
+/** SourceUtil.getBusinessRuleSourceCode — the platform's own primary key rule. */
+export function businessRuleSourceCode(schemaCode, ruleCode) {
+    return `${schemaCode}${ruleCode}Handler`;
+}
+function sha256(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function rowsOf(data) {
+    return Array.isArray(data) ? data.filter((entry) => asRecord(entry) !== null) : [];
+}
+/**
+ * The modern read/template face: POST /get_source. `code` omitted → the
+ * platform derives `schemaCode+ruleCode+"Handler"`; an unsaved draft comes back
+ * as an in-memory skeleton already filled with the rule-type template
+ * (SourceCodeModel.version = null marks "not persisted").
+ */
+async function readSource(session, args) {
+    const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+    try {
+        const response = await wireCall(session, {
+            path: ENDPOINTS.programmingGetSource,
+            method: "POST",
+            body: {
+                codeType: CODE_TYPE_BUSINESS_RULE,
+                schemaCode: args.schemaCode,
+                businessRuleCode: args.businessRuleCode,
+                ...(args.businessRuleName !== undefined ? { businessRuleName: args.businessRuleName } : {}),
+                ...(args.code !== undefined ? { code: args.code } : {}),
+            },
+        });
+        const model = asRecord(response.data);
+        if (model === null)
+            return { present: false, provisioned: false, model: null };
+        return { present: true, provisioned: typeof model.version === "number", model };
+    }
+    catch (error) {
+        if (error instanceof WireError && error.kind === "business" && /PROGRAMMING_SOURCE_NONEXISTENT|源码不存在|source.*nonexistent/i.test(error.message))
+            return { present: false, provisioned: false, model: null };
+        throw error;
+    }
+}
+/** Extract the declared `package` / top-level `class` name from Java source (best effort, textual). */
+function declaredShape(content) {
+    const pkg = content.match(/^\s*package\s+([A-Za-z_][\w.]*)\s*;/m);
+    // public class Foo / class Foo extends ...  (first class declaration wins)
+    const cls = content.match(/^\s*(?:public\s+)?(?:final\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/m);
+    return { ...(pkg ? { packageName: pkg[1] } : {}), ...(cls ? { className: cls[1] } : {}) };
+}
+/**
+ * The template guard (official dev guide: "不要修改在线代码所属的包路径及类名，
+ * 否则代码无法正常运行"). Refuse before the write gate so nothing reaches the
+ * environment; the class name must equal the platform-owned source code and a
+ * declared package must be the handler package.
+ */
+function assertTemplateShape(content, code) {
+    const shape = declaredShape(content);
+    if (shape.className !== undefined && shape.className !== code) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "programming-template-class-mismatch",
+            message: `源码声明的类名 ${shape.className} 与平台主键 ${code} 不一致。在线开发模板的类名由平台生成（schemaCode+ruleCode+"Handler"），改名后规则无法运行；请保留 ${code}。`,
+            expectedClassName: code,
+            declaredClassName: shape.className,
+        });
+    }
+    if (shape.packageName !== undefined && !TEMPLATE_PACKAGES.has(shape.packageName)) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "programming-template-package-mismatch",
+            message: `源码声明的包路径 ${shape.packageName} 不是平台模板的包（${TEMPLATE_PACKAGE_HINT}）。官方规范明确包路径不得修改（否则规则无法运行）；以 programming.get 返回的模板为准。`,
+            expectedPackages: [...TEMPLATE_PACKAGES],
+            declaredPackage: shape.packageName,
+        });
+    }
+}
+async function listRules(session, schemaCode) {
+    const response = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } });
+    return rowsOf(response.data);
+}
+async function ruleOf(session, schemaCode, ruleCode) {
+    return (await listRules(session, schemaCode)).find((row) => String(row.code ?? row.ruleCode ?? "") === ruleCode);
+}
+async function compileSource(session, code, content) {
+    const response = await wireCall(session, { path: ENDPOINTS.programmingCompile, method: "POST", body: { code, content } });
+    const result = asRecord(response.data) ?? {};
+    const success = result.success === true;
+    return {
+        success,
+        errors: result.errors ?? result.error ?? null,
+        diagnostics: {
+            ...(typeof result.message === "string" ? { message: result.message } : {}),
+            ...(Array.isArray(result.errorMessages) ? { errorMessages: result.errorMessages } : {}),
+        },
+    };
+}
+function sourceRollback() {
+    return {
+        target: (args) => `programming:${String(args.schemaCode ?? "")}/${String(args.businessRuleCode ?? "")}`,
+        read: async (session, args) => {
+            const read = await readSource(session, {
+                schemaCode: String(args.schemaCode),
+                businessRuleCode: String(args.businessRuleCode),
+            });
+            if (read.model === null)
+                return null;
+            return { content: read.model.content ?? null, provisioned: read.provisioned };
+        },
+        inverse: ({ before, args }) => {
+            const snapshot = before;
+            if (snapshot === null || typeof snapshot.content !== "string")
+                return { kind: "irreversible", reason: "before 读取不到既有草稿 content（未落库或读取失败），无法构造等价的回写调用" };
+            return {
+                kind: "calls",
+                calls: [{
+                        tool: "programming.save",
+                        args: {
+                            schemaCode: String(args.schemaCode),
+                            businessRuleCode: String(args.businessRuleCode),
+                            content: snapshot.content,
+                        },
+                    }],
+            };
+        },
+    };
+}
+export function registerProgrammingLane(tools) {
+    tools.push(defineTool({
+        name: "programming.schemas",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["programming.schemas"].scope,
+        description: TOOLS["programming.schemas"].description,
+        inputSchema: {
+            environment: environmentArg,
+            appCode: z.string().min(1),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const response = await wireCall(session, { path: ENDPOINTS.programmingListSchemas, query: { appCode: args.appCode } });
+            const schemas = rowsOf(response.data).map((row) => ({ code: String(row.code ?? ""), name: String(row.name ?? "") }));
+            return {
+                appCode: args.appCode,
+                schemas,
+                count: schemas.length,
+                hint: schemas.length === 0
+                    ? "该应用下没有**已存在在线源码**的模型（平台 list_schemas_by_appcode 只列 listSourceCodes 非空的模型）。要为某条业务规则新建编码源码，用 programming.get（模板生成）+ programming.publish；规则清单用 rule.list。"
+                    : "programming.sources 可按 schemaCode 列源码；未编码规则用 rule.list 发现后用 programming.get 生成模板。",
+            };
+        }),
+    }));
+    tools.push(defineTool({
+        name: "programming.sources",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["programming.sources"].scope,
+        description: TOOLS["programming.sources"].description,
+        inputSchema: {
+            environment: environmentArg,
+            schemaCode: z.string().min(1),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            try {
+                const response = await wireCall(session, { path: ENDPOINTS.programmingListSources, query: { schemaCode: args.schemaCode } });
+                const sources = rowsOf(response.data).map((row) => ({
+                    code: String(row.code ?? ""),
+                    businessRuleCode: String(row.businessRuleCode ?? ""),
+                    businessRuleName: typeof row.businessRuleName === "string" ? row.businessRuleName : undefined,
+                    className: typeof row.className === "string" ? row.className : undefined,
+                    contentBytes: typeof row.content === "string" ? Buffer.byteLength(row.content, "utf8") : undefined,
+                    contentSha256: typeof row.content === "string" ? sha256(row.content) : undefined,
+                    version: row.version ?? null,
+                    published: row.published === true,
+                }));
+                return { schemaCode: args.schemaCode, present: true, sources, count: sources.length };
+            }
+            catch (error) {
+                // Platform quirk (ProgrammingController.list): one rule missing a draft
+                // aborts the WHOLE list with PROGRAMMING_SOURCE_NONEXISTENT.
+                if (error instanceof WireError && error.kind === "business" && /PROGRAMMING_SOURCE_NONEXISTENT|源码不存在/i.test(error.message)) {
+                    return {
+                        schemaCode: args.schemaCode,
+                        present: false,
+                        sources: [],
+                        count: 0,
+                        hint: "平台的 list_source_by_schemacode 在任一规则缺草稿时整列报 PROGRAMMING_SOURCE_NONEXISTENT。逐条读取用 programming.get（未落库时返回模板骨架）。",
+                    };
+                }
+                throw error;
+            }
+        }),
+    }));
+    tools.push(defineTool({
+        name: "programming.get",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["programming.get"].scope,
+        description: TOOLS["programming.get"].description,
+        inputSchema: {
+            environment: environmentArg,
+            schemaCode: z.string().min(1),
+            businessRuleCode: z.string().min(1),
+            code: z.string().min(1).optional().describe("源码主键；省略时按 schemaCode+businessRuleCode+\"Handler\" 推导（SourceUtil 规则）"),
+            businessRuleName: z.string().optional(),
+            full: z.boolean().optional().describe("true = 输出完整 content（默认 content 内联但受通用 2KB diet 影响时会外置 artifact）"),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const read = await readSource(session, args);
+            const content = typeof read.model?.content === "string" ? read.model.content : null;
+            return {
+                schemaCode: args.schemaCode,
+                businessRuleCode: args.businessRuleCode,
+                code: String(read.model?.code ?? args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode)),
+                present: read.present,
+                provisioned: read.provisioned,
+                className: read.model?.className ?? null,
+                codeType: read.model?.codeType ?? null,
+                version: read.model?.version ?? null,
+                published: read.model?.published === true,
+                content,
+                contentSha256: content === null ? null : sha256(content),
+                contentBytes: content === null ? null : Buffer.byteLength(content, "utf8"),
+                ...(read.provisioned ? {} : { hint: "未落库草稿：content 是平台按规则类型生成的模板骨架（version:null）。改完后 programming.save 落库，programming.publish 生效。" }),
+            };
+        }, {
+            target: `programming.get:${args.schemaCode}/${args.businessRuleCode}`,
+            // The source IS the payload of this read: keep it inline rather than let
+            // the generic diet replace it with a key count.
+            compact: (result) => result,
+        }),
+    }));
+    tools.push(defineTool({
+        name: "programming.compile",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["programming.compile"].scope,
+        description: TOOLS["programming.compile"].description,
+        inputSchema: {
+            environment: environmentArg,
+            schemaCode: z.string().min(1),
+            businessRuleCode: z.string().min(1),
+            content: z.string().optional().describe("要编译的源码；省略时读远端草稿（未落库时用模板骨架）"),
+            code: z.string().min(1).optional(),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+            let content = args.content;
+            if (content === undefined) {
+                const read = await readSource(session, { schemaCode: args.schemaCode, businessRuleCode: args.businessRuleCode });
+                content = typeof read.model?.content === "string" ? read.model.content : undefined;
+            }
+            if (content === undefined || content.trim() === "")
+                return { status: "refused", blocker: "programming-content-required", message: "没有可编译的源码：传 content，或先 programming.save 落库草稿。" };
+            const result = await compileSource(session, code, content);
+            return {
+                schemaCode: args.schemaCode,
+                businessRuleCode: args.businessRuleCode,
+                code,
+                success: result.success,
+                errors: result.errors,
+                ...(result.success ? {} : { hint: "编译失败时规则无法运行（运行时每次执行都重新编译）。按 errors 修正后再 publish。" }),
+            };
+        }),
+    }));
+    writeTool(tools, "programming.save", LANE, TOOLS["programming.save"].scope, TOOLS["programming.save"].description, {
+        schemaCode: z.string().min(1),
+        businessRuleCode: z.string().min(1),
+        content: z.string().min(1),
+        code: z.string().min(1).optional(),
+        businessRuleName: z.string().optional(),
+        appCode: z.string().optional(),
+    }, async (session, args) => {
+        const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+        const response = await wireCall(session, {
+            path: ENDPOINTS.programmingSaveSource,
+            method: "POST",
+            body: {
+                code,
+                codeType: CODE_TYPE_BUSINESS_RULE,
+                schemaCode: args.schemaCode,
+                businessRuleCode: args.businessRuleCode,
+                ...(args.businessRuleName !== undefined ? { businessRuleName: args.businessRuleName } : {}),
+                ...(args.appCode !== undefined ? { appCode: args.appCode } : {}),
+                className: code,
+                content: args.content,
+            },
+        });
+        const saved = asRecord(response.data);
+        const readback = await readSource(session, { schemaCode: args.schemaCode, businessRuleCode: args.businessRuleCode, code });
+        const readbackContent = typeof readback.model?.content === "string" ? readback.model.content : null;
+        return {
+            performed: { errcode: 0, code, version: saved?.version ?? null, contentSha256: sha256(args.content), contentBytes: Buffer.byteLength(args.content, "utf8") },
+            readback: {
+                present: readback.present,
+                provisioned: readback.provisioned,
+                version: readback.model?.version ?? null,
+                contentMatches: readbackContent === args.content,
+                contentSha256: readbackContent === null ? null : sha256(readbackContent),
+                published: readback.model?.published === true,
+                note: "草稿保存不改变运行时——生效需 programming.publish。",
+            },
+        };
+    }, (args) => {
+        const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+        assertTemplateShape(args.content, code);
+    }, async (_session, args) => {
+        const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+        return {
+            code,
+            contentSha256: sha256(args.content),
+            contentBytes: Buffer.byteLength(args.content, "utf8"),
+            note: "dry-run 已执行模板校验（包路径/类名）；真写会覆盖远端草稿 content（平台无乐观锁）。",
+        };
+    }, sourceRollback());
+    writeTool(tools, "programming.publish", LANE, TOOLS["programming.publish"].scope, TOOLS["programming.publish"].description, {
+        schemaCode: z.string().min(1),
+        businessRuleCode: z.string().min(1),
+        content: z.string().optional().describe("要发布的源码；省略时用远端草稿（未落库则用模板骨架，会因模板未实现而编译通过但语义为空——通常应传 content）"),
+        code: z.string().min(1).optional(),
+        businessRuleName: z.string().optional(),
+        appCode: z.string().optional(),
+    }, async (session, args) => {
+        const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+        const rule = await ruleOf(session, args.schemaCode, args.businessRuleCode);
+        if (!rule) {
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "programming-rule-absent",
+                message: `业务规则 ${args.schemaCode}/${args.businessRuleCode} 不存在：publish 必须携带 businessRule 整模型（平台据此把规则切 CODING+enable+发布）。先 rule.create/rule.list 确认规则存在。`,
+            });
+        }
+        let content = args.content;
+        if (content === undefined) {
+            const read = await readSource(session, { schemaCode: args.schemaCode, businessRuleCode: args.businessRuleCode });
+            content = typeof read.model?.content === "string" ? read.model.content : undefined;
+        }
+        if (content === undefined || content.trim() === "")
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "programming-content-required",
+                message: "没有可发布的源码：传 content，或先 programming.save 落库草稿。",
+            });
+        assertTemplateShape(content, code);
+        // Explicit compile gate: the server compiles again inside publish, but a
+        // failed compile must surface its diagnostics BEFORE any write is admitted.
+        const compiled = await compileSource(session, code, content);
+        if (!compiled.success) {
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "programming-compile-failed",
+                message: "编译失败，拒绝发布（运行时每次执行都重新编译——坏源码会让该规则的每次业务执行失败）。按 errors 修正后重试。",
+                errors: compiled.errors,
+                diagnostics: compiled.diagnostics,
+            });
+        }
+        const response = await wireCall(session, {
+            path: ENDPOINTS.programmingPublish,
+            method: "POST",
+            body: {
+                code,
+                codeType: CODE_TYPE_BUSINESS_RULE,
+                schemaCode: args.schemaCode,
+                businessRuleCode: args.businessRuleCode,
+                ...(args.businessRuleName !== undefined ? { businessRuleName: args.businessRuleName } : {}),
+                ...(args.appCode !== undefined ? { appCode: args.appCode } : {}),
+                className: code,
+                content,
+                businessRule: rule,
+            },
+        });
+        // Readback: draft content must equal what we published, and the rule must
+        // now be in coding mode + enabled (the platform's publishBusinessRule
+        // side effect). published content itself has no wire read endpoint.
+        const readbackSource = await readSource(session, { schemaCode: args.schemaCode, businessRuleCode: args.businessRuleCode, code });
+        const readbackRule = await ruleOf(session, args.schemaCode, args.businessRuleCode);
+        const readbackContent = typeof readbackSource.model?.content === "string" ? readbackSource.model.content : null;
+        return {
+            performed: { errcode: 0, code, contentSha256: sha256(content), contentBytes: Buffer.byteLength(content, "utf8"), compiled: true },
+            readback: {
+                present: readbackSource.present,
+                contentMatches: readbackContent === content,
+                developmentMode: readbackRule?.developmentMode ?? readbackRule?.development_mode ?? null,
+                enabled: readbackRule?.enabled ?? null,
+                publishStatus: readbackRule?.publishStatus ?? null,
+                publishedFlag: readbackSource.model?.published === true,
+                note: "运行时执行的是 published 最新版；published 内容无 wire 读取端点，回滚靠本地 git + 重新 publish。",
+            },
+        };
+    }, (args) => {
+        const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+        if (args.content !== undefined)
+            assertTemplateShape(args.content, code);
+    }, async (_session, args) => ({
+        code: args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode),
+        contentSha256: args.content === undefined ? null : sha256(args.content),
+        note: "dry-run 已执行模板校验；真写会 compile→publish（插新 published 版本行并把规则切 CODING+enable）。",
+    }));
+}
+export { PROGRAMMING_WIRE };
+//# sourceMappingURL=programming.js.map