@stalfh233/omc-cli 0.5.15 → 0.6.0

package/dist/programming-workflow.js

@@ -0,0 +1,793 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { ENDPOINTS } from "./endpoints.js";
+import { ConfigStore, defaultPaths } from "./config-store.js";
+import { SessionManager } from "./session-manager.js";
+import { makeToolContext } from "./context.js";
+import { withoutReadbackCache } from "./read.js";
+import { runToolCall } from "./call.js";
+import { ToolRefusalError } from "./tool-types.js";
+import { wireCall, WireError, wireRows } from "./wire.js";
+/**
+ * `omc programming` — the file-based working copy for the design-time
+ * 在线开发 face. The platform is the remote; `.omc-programming/` is the local
+ * tree; the user's git is the history layer (the platform only keeps one draft
+ * row plus the published rows, and published content has no wire read
+ * endpoint — see .scratch/backend-online-coding/recon.md §8).
+ *
+ * Commands:
+ *   pull    remote → tree + manifest (environment-stamped)
+ *   status  local edits vs manifest, plus optional remote drift (--deep)
+ *   apply   changed files → programming.save (→ --publish)
+ *   adopt   graphical rule → coding mode: template into the tree
+ *   test    compile → publish → trigger → assertions → cleanup (fixture-driven)
+ *
+ * The writes go through the REGISTRY tools (runToolCall) so the governed
+ * pipeline (writable gate, production confirmation, write lock, audit
+ * artifacts, requestId idempotency) applies exactly as in `omc call`.
+ */
+const DIR_NAME = ".omc-programming";
+const MANIFEST_VERSION = 1;
+export function workspacePaths(cwd = process.cwd()) {
+    const root = join(cwd, DIR_NAME);
+    return { root, manifestFile: join(root, "manifest.json"), sourcesDir: join(root, "sources"), testsDir: join(root, "tests") };
+}
+export function sourceFilePath(paths, schemaCode, ruleCode) {
+    return join(paths.sourcesDir, schemaCode, `${ruleCode}.java`);
+}
+export function fixtureFilePath(paths, schemaCode, ruleCode) {
+    return join(paths.testsDir, schemaCode, `${ruleCode}.yaml`);
+}
+function sha256(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function ruleKey(schemaCode, ruleCode) {
+    return `${schemaCode}#${ruleCode}`;
+}
+export function readManifest(paths) {
+    if (!existsSync(paths.manifestFile))
+        return null;
+    return JSON.parse(readFileSync(paths.manifestFile, "utf8"));
+}
+function writeManifest(paths, manifest) {
+    mkdirSync(paths.root, { recursive: true });
+    const ordered = {
+        ...manifest,
+        rules: Object.fromEntries(Object.entries(manifest.rules).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))),
+        published: Object.fromEntries(Object.entries(manifest.published).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))),
+    };
+    writeFileSync(paths.manifestFile, JSON.stringify(ordered, null, 2) + "\n", "utf8");
+}
+/** Environment stamp gate: a tree pulled from one environment must not apply to another. */
+export function assertManifestEnvironment(manifest, environment, baseUrl) {
+    if (manifest.environment !== environment || manifest.baseUrl !== baseUrl) {
+        throw Object.assign(new Error(`本地工作区属于环境 "${manifest.environment}"（${manifest.baseUrl}），不是 "${environment}"（${baseUrl}）。每个环境独立 pull；不许跨环境套用（同 omc-graph 的防跨环境语义）。`), { blocker: "programming-workspace-environment-mismatch" });
+    }
+}
+/**
+ * Read the whole programming face for one application. Schemas come from
+ * list_schemas_by_appcode (only models with existing sources); each schema's
+ * source list carries the draft content. A schema whose list aborts (the
+ * platform throws PROGRAMMING_SOURCE_NONEXISTENT if any draft is missing) is
+ * recorded as a gap, never silently dropped.
+ */
+async function readRemoteSources(session, applicationCode) {
+    const schemas = wireRows((await wireCall(session, { path: ENDPOINTS.programmingListSchemas, query: { appCode: applicationCode } })).data);
+    const sources = [];
+    const gaps = [];
+    for (const schema of schemas) {
+        const schemaCode = String(schema.code ?? "");
+        if (!schemaCode)
+            continue;
+        try {
+            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.programmingListSources, query: { schemaCode } })).data);
+            for (const row of rows) {
+                const ruleCode = String(row.businessRuleCode ?? "");
+                const content = typeof row.content === "string" ? row.content : "";
+                if (!ruleCode || content === "")
+                    continue;
+                sources.push({ schemaCode, ruleCode, content, provisioned: true });
+            }
+        }
+        catch (error) {
+            if (error instanceof WireError && error.kind === "business") {
+                gaps.push({ schemaCode, reason: error.message });
+                continue;
+            }
+            throw error;
+        }
+    }
+    return { applicationCode, sources, schemas: schemas.length, gaps };
+}
+/** `omc programming pull` — remote → local tree + manifest. */
+export async function cmdProgrammingPull(options) {
+    const paths = workspacePaths(options.cwd);
+    const context = options.ctx ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
+    const session = await context.sessions.session(options.environment);
+    const profileApplicationCode = session.profile.applicationCode;
+    const applicationCode = options.appCode ?? profileApplicationCode;
+    if (!applicationCode) {
+        return { status: "refused", blocker: "programming-application-code-required", message: "缺少应用编码：传 --app <appCode>，或先在环境配置里设置 applicationCode（omc setup）。" };
+    }
+    const remote = await readRemoteSources(session, applicationCode);
+    const previous = readManifest(paths);
+    const rules = {};
+    for (const source of remote.sources) {
+        const key = ruleKey(source.schemaCode, source.ruleCode);
+        rules[key] = {
+            schemaCode: source.schemaCode,
+            ruleCode: source.ruleCode,
+            appCode: applicationCode,
+            code: `${source.schemaCode}${source.ruleCode}Handler`,
+            draftSha256: sha256(source.content),
+            provisioned: source.provisioned,
+        };
+        const file = sourceFilePath(paths, source.schemaCode, source.ruleCode);
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, source.content, "utf8");
+    }
+    const manifest = {
+        manifestVersion: MANIFEST_VERSION,
+        environment: session.environmentName,
+        baseUrl: session.profile.baseUrl,
+        applicationCode,
+        pulledAtIso: new Date().toISOString(),
+        rules,
+        // Published knowledge survives a pull: only WE know what we last pushed.
+        published: previous?.published ?? {},
+    };
+    writeManifest(paths, manifest);
+    return {
+        status: "ok",
+        environment: session.environmentName,
+        applicationCode,
+        directory: paths.root,
+        pulledAtIso: manifest.pulledAtIso,
+        schemas: remote.schemas,
+        rules: Object.keys(rules).length,
+        ...(remote.gaps.length > 0 ? { gaps: remote.gaps } : {}),
+        nextCommand: "改 .omc-programming/sources/**/*.java → omc programming status → omc programming apply --publish",
+    };
+}
+/** Walk the tree; classify edits against the manifest hashes. */
+export function diffLocalTree(paths, manifest) {
+    const diff = { modified: [], untracked: [], deleted: [], unpublished: [] };
+    const seen = new Set();
+    const walk = (dir) => {
+        if (!existsSync(dir))
+            return;
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!entry.name.endsWith(".java"))
+                continue;
+            // Root-relative on purpose: apply() resolves targets against paths.root.
+            const rel = relative(paths.root, full);
+            const treeRel = relative(paths.sourcesDir, full);
+            const [schemaCode, file] = treeRel.split("/");
+            const ruleCode = file.replace(/\.java$/, "");
+            const key = ruleKey(schemaCode ?? "", ruleCode);
+            seen.add(key);
+            const content = readFileSync(full, "utf8");
+            const digest = sha256(content);
+            const known = manifest.rules[key];
+            if (!known)
+                diff.untracked.push(rel);
+            else if (known.draftSha256 !== digest)
+                diff.modified.push(rel);
+            const published = manifest.published[key];
+            if (known && (published === undefined || published.sha256 !== digest))
+                diff.unpublished.push(rel);
+        }
+    };
+    walk(paths.sourcesDir);
+    for (const [key, rule] of Object.entries(manifest.rules)) {
+        if (!seen.has(key))
+            diff.deleted.push(join("sources", rule.schemaCode, `${rule.ruleCode}.java`));
+    }
+    return diff;
+}
+/** `omc programming status` — local edits + optional remote drift. */
+export async function cmdProgrammingStatus(options) {
+    const paths = workspacePaths(options.cwd);
+    const context = options.ctx ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
+    const session = await context.sessions.session(options.environment);
+    const manifest = readManifest(paths);
+    if (!manifest)
+        return { status: "refused", blocker: "programming-workspace-absent", message: "本地没有 .omc-programming/。先 omc programming pull --env <env> --app <appCode>。" };
+    try {
+        assertManifestEnvironment(manifest, session.environmentName, session.profile.baseUrl);
+    }
+    catch (error) {
+        return { status: "refused", blocker: error.blocker ?? "programming-workspace-environment-mismatch", message: error.message };
+    }
+    const local = diffLocalTree(paths, manifest);
+    const base = {
+        environment: session.environmentName,
+        directory: paths.root,
+        pulledAtIso: manifest.pulledAtIso,
+        local: {
+            modified: local.modified,
+            untracked: local.untracked,
+            deleted: local.deleted,
+            unpublished: local.unpublished,
+            dirty: local.modified.length + local.untracked.length + local.deleted.length > 0,
+        },
+    };
+    if (!options.deep)
+        return { status: "ok", ...base, hint: "--deep 再比对远端草稿（内容哈希）" };
+    const remote = await readRemoteSources(session, options.appCode ?? manifest.applicationCode);
+    const remoteByKey = new Map(remote.sources.map((source) => [ruleKey(source.schemaCode, source.ruleCode), source]));
+    const ahead = [];
+    const fresh = [];
+    const missing = [];
+    for (const [key, rule] of Object.entries(manifest.rules)) {
+        const remoteRule = remoteByKey.get(key);
+        if (!remoteRule) {
+            missing.push(key);
+            continue;
+        }
+        if (sha256(remoteRule.content) !== rule.draftSha256)
+            ahead.push(relative(paths.root, sourceFilePath(paths, rule.schemaCode, rule.ruleCode)));
+    }
+    for (const key of remoteByKey.keys())
+        if (!manifest.rules[key])
+            fresh.push(key);
+    return {
+        status: "ok",
+        ...base,
+        remote: {
+            ahead,
+            new: fresh,
+            absent: missing,
+            note: "平台无乐观锁：apply 前会用内容哈希做漂移门（advisory，非原子锁）。ahead 非空时先 pull 再改。",
+        },
+    };
+}
+/**
+ * Minimal YAML-subset parser for fixtures. Supports exactly the shapes a test
+ * fixture needs: nested maps, sequences of maps (`- key: value`), sequences of
+ * scalars, and inline JSON values ({...} / [...]). Anything else is a parse
+ * error — a fixture that silently loses its `asserts` would report a vacuous
+ * pass, which is worse than refusing.
+ */
+export function parseFixture(text) {
+    const lines = [];
+    for (const raw of text.split(/\r?\n/)) {
+        if (raw.trim() === "" || raw.trim().startsWith("#"))
+            continue;
+        lines.push({ indent: raw.length - raw.trimStart().length, text: raw.trim() });
+    }
+    let index = 0;
+    /** Split on top-level commas (nesting-aware, quote-aware). */
+    const splitInline = (inner) => {
+        const parts = [];
+        let depth = 0;
+        let quote = null;
+        let current = "";
+        for (const char of inner) {
+            if (quote !== null) {
+                current += char;
+                if (char === quote)
+                    quote = null;
+                continue;
+            }
+            if (char === '"' || char === "'") {
+                quote = char;
+                current += char;
+                continue;
+            }
+            if (char === "{" || char === "[")
+                depth += 1;
+            if (char === "}" || char === "]")
+                depth -= 1;
+            if (char === "," && depth === 0) {
+                parts.push(current);
+                current = "";
+                continue;
+            }
+            current += char;
+        }
+        if (current.trim() !== "")
+            parts.push(current);
+        return parts.map((part) => part.trim()).filter((part) => part !== "");
+    };
+    const parseScalar = (raw) => {
+        const value = raw.trim();
+        if (value === "true")
+            return true;
+        if (value === "false")
+            return false;
+        if (value === "null" || value === "~")
+            return null;
+        if (value.startsWith("{") && value.endsWith("}")) {
+            try {
+                return JSON.parse(value);
+            }
+            catch { /* fall through to the YAML-ish form */ }
+            const out = {};
+            for (const part of splitInline(value.slice(1, -1))) {
+                const sep = part.indexOf(":");
+                if (sep === -1)
+                    return value;
+                out[part.slice(0, sep).trim()] = parseScalar(part.slice(sep + 1));
+            }
+            return out;
+        }
+        if (value.startsWith("[") && value.endsWith("]")) {
+            try {
+                return JSON.parse(value);
+            }
+            catch { /* fall through */ }
+            return splitInline(value.slice(1, -1)).map(parseScalar);
+        }
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+            return value.slice(1, -1);
+        if (/^-?\d+(\.\d+)?$/.test(value))
+            return Number(value);
+        return value;
+    };
+    const parseBlock = (indent) => {
+        if (index >= lines.length || lines[index].indent < indent)
+            return null;
+        const first = lines[index];
+        if (first.indent > indent)
+            throw new Error(`fixture 缩进异常（行 ${index + 1}）`);
+        return first.text.startsWith("- ") || first.text === "-" ? parseSequence(first.indent) : parseMap(first.indent);
+    };
+    const parseSequence = (indent) => {
+        const out = [];
+        while (index < lines.length && lines[index].indent === indent && (lines[index].text.startsWith("- ") || lines[index].text === "-")) {
+            const text = lines[index].text;
+            const rest = text === "-" ? "" : text.slice(2).trim();
+            index += 1;
+            if (rest === "") {
+                out.push(index < lines.length && lines[index].indent > indent ? parseBlock(lines[index].indent) : null);
+                continue;
+            }
+            const colon = rest.indexOf(":");
+            if (colon === -1) {
+                out.push(parseScalar(rest));
+                continue;
+            }
+            // "- key: value" starts a map item; following deeper lines belong to it.
+            const item = {};
+            const key = rest.slice(0, colon).trim();
+            const valueRaw = rest.slice(colon + 1).trim();
+            item[key] = valueRaw === "" ? null : parseScalar(valueRaw);
+            if (valueRaw === "" && index < lines.length && lines[index].indent > indent)
+                item[key] = parseBlock(lines[index].indent);
+            while (index < lines.length && lines[index].indent > indent && !lines[index].text.startsWith("- ")) {
+                const line = lines[index];
+                const sep = line.text.indexOf(":");
+                if (sep === -1)
+                    throw new Error(`fixture 行无法解析：${line.text}`);
+                const childKey = line.text.slice(0, sep).trim();
+                const childValue = line.text.slice(sep + 1).trim();
+                index += 1;
+                item[childKey] = childValue === "" ? (index < lines.length && lines[index].indent > line.indent ? parseBlock(lines[index].indent) : null) : parseScalar(childValue);
+            }
+            out.push(item);
+        }
+        return out;
+    };
+    const parseMap = (indent) => {
+        const out = {};
+        while (index < lines.length && lines[index].indent === indent && !lines[index].text.startsWith("- ")) {
+            const line = lines[index];
+            const sep = line.text.indexOf(":");
+            if (sep === -1)
+                throw new Error(`fixture 行无法解析：${line.text}`);
+            const key = line.text.slice(0, sep).trim();
+            const valueRaw = line.text.slice(sep + 1).trim();
+            index += 1;
+            if (valueRaw === "") {
+                out[key] = index < lines.length && lines[index].indent > indent ? parseBlock(lines[index].indent) : {};
+            }
+            else {
+                out[key] = parseScalar(valueRaw);
+            }
+        }
+        return out;
+    };
+    const parsed = parseBlock(0);
+    if (index !== lines.length)
+        throw new Error("fixture 有未消费的行（缩进不一致）");
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("fixture 顶层必须是映射");
+    return parsed;
+}
+/**
+ * Invoke a registry tool through the governed pipeline, returning its result.
+ * Reads run with the readback-cache short-circuit disabled: a composer calling
+ * `programming.compile` twice with identical content must get the REAL verdict
+ * both times, not the `{unchanged:true}` stub the single-call diet returns.
+ */
+async function callTool(tool, args, ctx) {
+    const run = async () => {
+        const { result } = await runToolCall(tool, { args, print: () => undefined, ...(ctx ? { context: ctx } : {}) });
+        return result;
+    };
+    return ctx ? withoutReadbackCache(ctx, run) : run();
+}
+function okOrThrow(tool, outcome) {
+    if (outcome.status === "ok" || outcome.status === "dry-run")
+        return outcome;
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: `programming-apply-${tool.replace(/\./g, "-")}-${String(outcome.blocker ?? outcome.status ?? "failed")}`,
+        message: `按文件应用时 ${tool} 失败：${String(outcome.message ?? "")}`,
+        cause: outcome,
+    });
+}
+/** `omc programming apply` — changed files → governed save (→ publish). */
+export async function cmdProgrammingApply(options) {
+    const paths = workspacePaths(options.cwd);
+    const manifest = readManifest(paths);
+    if (!manifest)
+        return { status: "refused", blocker: "programming-workspace-absent", message: "本地没有 .omc-programming/。先 omc programming pull --env <env> --app <appCode>。" };
+    const context = options.ctx ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
+    const session = await context.sessions.session(options.environment);
+    try {
+        assertManifestEnvironment(manifest, session.environmentName, session.profile.baseUrl);
+    }
+    catch (error) {
+        return { status: "refused", blocker: error.blocker ?? "programming-workspace-environment-mismatch", message: error.message };
+    }
+    // Target selection: explicit files, else modified + untracked.
+    const diff = diffLocalTree(paths, manifest);
+    const targets = options.files !== undefined
+        ? options.files.map((file) => {
+            const relativePath = relative(paths.root, file.startsWith("/") ? file : join(options.cwd ?? process.cwd(), file));
+            return relativePath.startsWith("sources/") ? relativePath : relativePath;
+        })
+        : [...diff.modified, ...diff.untracked];
+    if (targets.length === 0)
+        return { status: "ok", changed: 0, message: "工作区无改动（本地与 manifest 一致）。", directory: paths.root };
+    const results = [];
+    for (const target of targets) {
+        const absolute = target.startsWith("/") ? target : join(paths.root, target);
+        if (!existsSync(absolute)) {
+            results.push({ file: target, schemaCode: "", ruleCode: "", error: "文件不存在" });
+            continue;
+        }
+        const content = readFileSync(absolute, "utf8");
+        const rel = relative(paths.sourcesDir, absolute);
+        const [schemaCode = "", file = ""] = rel.split("/");
+        const ruleCode = file.replace(/\.java$/, "");
+        const key = ruleKey(schemaCode, ruleCode);
+        const known = manifest.rules[key];
+        if (!known) {
+            results.push({ file: target, schemaCode, ruleCode, error: "未在 manifest 中：先 pull（或 adopt）登记该规则，避免无主写入" });
+            continue;
+        }
+        // Advisory drift gate (the platform has no optimistic lock): the remote
+        // draft must still hash to what we pulled, else someone else edited it.
+        try {
+            const remote = await callTool("programming.get", { environment: session.environmentName, schemaCode, businessRuleCode: ruleCode }, context);
+            const remoteSha = typeof remote.contentSha256 === "string" ? remote.contentSha256 : null;
+            const provisioned = remote.provisioned === true;
+            if (known.draftSha256 !== null && provisioned && remoteSha !== known.draftSha256) {
+                results.push({
+                    file: target,
+                    schemaCode,
+                    ruleCode,
+                    error: `remote-ahead：远端草稿已在 pull 之后被改动（manifest ${known.draftSha256.slice(0, 12)}… ≠ 远端 ${String(remoteSha).slice(0, 12)}…）。先 omc programming pull 再改（平台无乐观锁，这是 CLI 的 advisory 门）。`,
+                });
+                continue;
+            }
+        }
+        catch (error) {
+            results.push({ file: target, schemaCode, ruleCode, error: `漂移门读取失败：${error.message}` });
+            continue;
+        }
+        try {
+            const save = await callTool("programming.save", {
+                environment: session.environmentName,
+                schemaCode,
+                businessRuleCode: ruleCode,
+                content,
+                ...(options.dryRun === true ? { dryRun: true } : {}),
+            }, context);
+            const outcome = { file: target, schemaCode, ruleCode, save };
+            if (save.status !== "ok" && save.status !== "dry-run") {
+                outcome.error = String(save.message ?? save.blocker ?? save.status);
+                results.push(outcome);
+                continue;
+            }
+            if (options.dryRun !== true) {
+                known.draftSha256 = sha256(content);
+                manifest.rules[key] = known;
+            }
+            if (options.publish === true && options.dryRun !== true) {
+                const published = await callTool("programming.publish", {
+                    environment: session.environmentName,
+                    schemaCode,
+                    businessRuleCode: ruleCode,
+                    content,
+                }, context);
+                outcome.publish = published;
+                if (published.status !== "ok")
+                    outcome.error = String(published.message ?? published.blocker ?? published.status);
+                else {
+                    manifest.published[key] = { sha256: sha256(content), atIso: new Date().toISOString(), environment: session.environmentName };
+                }
+            }
+            results.push(outcome);
+        }
+        catch (error) {
+            results.push({ file: target, schemaCode, ruleCode, error: error.message });
+        }
+    }
+    if (options.dryRun !== true)
+        writeManifest(paths, manifest);
+    const failed = results.filter((entry) => entry.error !== undefined);
+    return {
+        status: failed.length === 0 ? "ok" : failed.length === results.length ? "refused" : "partial",
+        environment: session.environmentName,
+        applied: results.length - failed.length,
+        failed: failed.length,
+        results,
+        ...(options.publish === true ? { published: true } : {}),
+        ...(options.dryRun === true ? { dryRun: true } : {}),
+    };
+}
+/** `omc programming adopt` — graphical rule → coding mode (template into the tree). */
+export async function cmdProgrammingAdopt(options) {
+    const paths = workspacePaths(options.cwd);
+    const context = options.ctx ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
+    const session = await context.sessions.session(options.environment);
+    const { schemaCode, ruleCode } = options;
+    // The rule must exist; publish carries its full model and flips it to CODING.
+    const rules = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } })).data);
+    const rule = rules.find((row) => String(row.code ?? row.ruleCode ?? "") === ruleCode);
+    if (!rule) {
+        return { status: "refused", blocker: "programming-rule-absent", message: `模型 ${schemaCode} 没有规则 ${ruleCode}——先 rule.list 核对 code，或 rule.save 新建。` };
+    }
+    const source = await callTool("programming.get", { environment: session.environmentName, schemaCode, businessRuleCode: ruleCode }, context);
+    if (source.status !== "ok")
+        return { status: source.status, blocker: source.blocker, message: source.message, source };
+    const content = String(source.content ?? "");
+    if (content === "")
+        return { status: "refused", blocker: "programming-template-empty", message: "平台没有返回该规则的模板源码。" };
+    const file = sourceFilePath(paths, schemaCode, ruleCode);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, content, "utf8");
+    const manifest = readManifest(paths) ?? {
+        manifestVersion: MANIFEST_VERSION,
+        environment: session.environmentName,
+        baseUrl: session.profile.baseUrl,
+        applicationCode: String(rule.appCode ?? session.profile.applicationCode ?? ""),
+        pulledAtIso: new Date().toISOString(),
+        rules: {},
+        published: {},
+    };
+    try {
+        assertManifestEnvironment(manifest, session.environmentName, session.profile.baseUrl);
+    }
+    catch (error) {
+        return { status: "refused", blocker: error.blocker ?? "programming-workspace-environment-mismatch", message: error.message };
+    }
+    const key = ruleKey(schemaCode, ruleCode);
+    manifest.rules[key] = {
+        schemaCode,
+        ruleCode,
+        appCode: manifest.applicationCode,
+        code: `${schemaCode}${ruleCode}Handler`,
+        draftSha256: typeof source.contentSha256 === "string" ? source.contentSha256 : sha256(content),
+        provisioned: source.provisioned === true,
+    };
+    writeManifest(paths, manifest);
+    return {
+        status: "ok",
+        environment: session.environmentName,
+        schemaCode,
+        ruleCode,
+        file: relative(paths.root, file),
+        provisioned: source.provisioned === true,
+        developmentMode: rule.developmentMode ?? null,
+        nextCommand: `改 ${relative(paths.root, file)} → omc programming apply --env ${session.environmentName} --file ${relative(paths.root, file)} --publish（publish 内部会把规则切 CODING+enable）`,
+    };
+}
+function matchExpectation(row, expect) {
+    const mismatches = [];
+    const data = (row.data ?? row);
+    for (const [field, expected] of Object.entries(expect)) {
+        const actual = data[field];
+        if (expected !== undefined && String(actual) !== String(expected))
+            mismatches.push({ field, expected, actual });
+    }
+    return { ok: mismatches.length === 0, mismatches };
+}
+function filterOf(filter) {
+    const entries = Object.entries(filter);
+    if (entries.length === 0)
+        return {};
+    if (typeof filter.op === "string")
+        return { filters: [filter] };
+    return { filters: entries.map(([field, value]) => ({ op: "eq", field, value })) };
+}
+/** `omc programming test` — fixture-driven end-to-end verification. */
+export async function cmdProgrammingTest(options) {
+    const paths = workspacePaths(options.cwd);
+    const manifest = readManifest(paths);
+    if (!manifest)
+        return { status: "refused", blocker: "programming-workspace-absent", message: "本地没有 .omc-programming/。先 omc programming pull --env <env> --app <appCode>。" };
+    const context = options.ctx ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
+    const session = await context.sessions.session(options.environment);
+    try {
+        assertManifestEnvironment(manifest, session.environmentName, session.profile.baseUrl);
+    }
+    catch (error) {
+        return { status: "refused", blocker: error.blocker ?? "programming-workspace-environment-mismatch", message: error.message };
+    }
+    // Resolve target rule → source file + fixture.
+    let schemaCode = options.schemaCode;
+    let ruleCode = options.ruleCode;
+    if ((!schemaCode || !ruleCode) && options.file) {
+        const absolute = options.file.startsWith("/") ? options.file : join(paths.root, options.file);
+        const rel = relative(paths.sourcesDir, absolute);
+        const [schema, file] = rel.split("/");
+        schemaCode = schemaCode ?? schema;
+        ruleCode = ruleCode ?? file?.replace(/\.java$/, "");
+    }
+    if (!schemaCode || !ruleCode)
+        return { status: "refused", blocker: "programming-test-target-required", message: "指定被测规则：--schema <code> --rule <code>，或 --file .omc-programming/sources/<schema>/<rule>.java。" };
+    const sourceFile = sourceFilePath(paths, schemaCode, ruleCode);
+    if (!existsSync(sourceFile))
+        return { status: "refused", blocker: "programming-test-source-absent", message: `本地没有源码文件 ${relative(paths.root, sourceFile)}——先 pull 或 adopt。` };
+    const content = readFileSync(sourceFile, "utf8");
+    const fixtureFile = options.fixture ?? fixtureFilePath(paths, schemaCode, ruleCode);
+    if (!existsSync(fixtureFile))
+        return { status: "refused", blocker: "programming-test-fixture-absent", message: `没有测试 fixture：${fixtureFile}。创建 trigger/asserts/cleanup 三段后重试。` };
+    let fixture;
+    try {
+        fixture = parseFixture(readFileSync(fixtureFile, "utf8"));
+    }
+    catch (error) {
+        return { status: "refused", blocker: "programming-test-fixture-invalid", message: `fixture 解析失败：${error.message}` };
+    }
+    const trigger = (fixture.trigger ?? {});
+    const declaredAsserts = fixture.asserts;
+    if (declaredAsserts !== undefined && !Array.isArray(declaredAsserts)) {
+        return { status: "refused", blocker: "programming-test-fixture-asserts-object", message: "fixture.asserts 必须是列表（`asserts:` 下用 `- data: {...}`），对象形状无法逐条断言。" };
+    }
+    if (Array.isArray(declaredAsserts) && declaredAsserts.length === 0) {
+        return { status: "refused", blocker: "programming-test-fixture-asserts-empty", message: "fixture.asserts 为空：没有断言的测试只证明「调用没抛异常」，请至少声明一条 data 断言。" };
+    }
+    const action = String(trigger.action ?? "create");
+    const report = { environment: session.environmentName, schemaCode, ruleCode, action };
+    // 1. Static gate.
+    const compiled = await callTool("programming.compile", { environment: session.environmentName, schemaCode, businessRuleCode: ruleCode, content }, context);
+    report.compile = { success: compiled.success === true, ...(compiled.success === true ? {} : { errors: compiled.errors }) };
+    if (compiled.success !== true)
+        return { status: "refused", blocker: "programming-compile-failed", message: "编译失败，测试短路。", ...report };
+    // 2. Publish (skip when this exact content is already what we published).
+    const key = ruleKey(schemaCode, ruleCode);
+    const digest = sha256(content);
+    const alreadyPublished = manifest.published[key]?.sha256 === digest && manifest.published[key]?.environment === session.environmentName;
+    if (options.forcePublish === true || !alreadyPublished) {
+        const published = await callTool("programming.publish", { environment: session.environmentName, schemaCode, businessRuleCode: ruleCode, content }, context);
+        report.publish = { status: published.status, ...(published.status === "ok" ? { developmentMode: published.readback?.developmentMode ?? null } : { blocker: published.blocker, message: published.message }) };
+        if (published.status !== "ok")
+            return { status: "refused", blocker: String(published.blocker ?? "programming-publish-failed"), message: String(published.message ?? "发布失败。"), ...report };
+        manifest.published[key] = { sha256: digest, atIso: new Date().toISOString(), environment: session.environmentName };
+        writeManifest(paths, manifest);
+    }
+    else {
+        report.publish = { status: "ok", reused: true, note: "本地记录该内容已是最近发布版；--force-publish 强制重发。" };
+    }
+    // 3. Trigger.
+    const data = (trigger.data ?? {});
+    const seededIds = [];
+    let triggerOutcome;
+    try {
+        switch (action) {
+            case "create": {
+                triggerOutcome = await callTool("data.save", { environment: session.environmentName, schemaCode, formData: data }, context);
+                const performed = (triggerOutcome.performed ?? {});
+                const readback = (triggerOutcome.readback ?? {});
+                const objectId = String(performed.bizObjectId ?? performed.objectId ?? readback.objectId ?? readback.bizObjectId ?? "");
+                if (objectId)
+                    seededIds.push(objectId);
+                break;
+            }
+            case "update": {
+                const id = String(data.id ?? "");
+                if (!id)
+                    return { status: "refused", blocker: "programming-test-update-id-required", message: "update 触发需要在 fixture.trigger.data.id 指定既有业务数据 id。", ...report };
+                seededIds.push(id);
+                triggerOutcome = await callTool("data.save", { environment: session.environmentName, schemaCode, formData: data }, context);
+                break;
+            }
+            case "delete": {
+                const id = String(data.id ?? "");
+                if (!id)
+                    return { status: "refused", blocker: "programming-test-delete-id-required", message: "delete 触发需要在 fixture.trigger.data.id 指定业务数据 id。", ...report };
+                seededIds.push(id);
+                triggerOutcome = await callTool("data.delete", { environment: session.environmentName, schemaCode, bizObjectId: id }, context);
+                break;
+            }
+            case "load": {
+                const id = String(data.id ?? "");
+                if (!id)
+                    return { status: "refused", blocker: "programming-test-load-id-required", message: "load 触发需要在 fixture.trigger.data.id 指定业务数据 id。", ...report };
+                triggerOutcome = await callTool("data.load", { environment: session.environmentName, schemaCode, bizObjectId: id }, context);
+                break;
+            }
+            case "custom": {
+                const ids = Array.isArray(trigger.ids) ? trigger.ids.map(String) : seededIds;
+                if (ids.length === 0)
+                    return { status: "refused", blocker: "programming-test-custom-ids-required", message: "custom 触发需要在 fixture.trigger.ids 指定要执行规则的业务数据 id。", ...report };
+                triggerOutcome = await callTool("rule.run", { environment: session.environmentName, schemaCode, ruleCode, ids }, context);
+                break;
+            }
+            default:
+                return { status: "refused", blocker: "programming-test-trigger-unknown", message: `不支持的 trigger.action: ${action}（create|update|delete|load|custom）`, ...report };
+        }
+    }
+    catch (error) {
+        return { status: "refused", blocker: "programming-test-trigger-threw", message: error.message, ...report };
+    }
+    // The coded rule runs INLINE: the trigger response is the primary success
+    // signal (coded rules write no RuleLog — see recon §7.6).
+    report.trigger = { tool: action === "custom" ? "rule.run" : `data.${action === "create" || action === "update" ? "save" : action}`, status: triggerOutcome.status, ...(triggerOutcome.status !== "ok" ? { blocker: triggerOutcome.blocker, message: triggerOutcome.message, errcode: triggerOutcome.errcode } : {}) };
+    if (triggerOutcome.status !== "ok") {
+        return { status: "refused", blocker: `programming-test-trigger-${String(triggerOutcome.blocker ?? triggerOutcome.status)}`, message: `规则/触发执行失败：${String(triggerOutcome.message ?? "")}`, ...report };
+    }
+    // 4. Assertions.
+    const asserts = Array.isArray(fixture.asserts ?? undefined) ? fixture.asserts : [];
+    const assertReports = [];
+    let assertsFailed = 0;
+    for (const entry of asserts) {
+        const spec = entry;
+        const dataSpec = (spec.data ?? {});
+        const targetSchema = String(dataSpec.schema ?? schemaCode);
+        const filter = (dataSpec.filter ?? {});
+        const expect = (dataSpec.expect ?? {});
+        const listed = await callTool("data.list", {
+            environment: session.environmentName,
+            schemaCode: targetSchema,
+            ...filterOf(filter),
+            displayFields: Object.keys(expect),
+        }, context);
+        const rows = (listed.rows ?? listed.items ?? []);
+        const matched = rows.filter((row) => matchExpectation(row, expect).ok);
+        const ok = matched.length > 0;
+        if (!ok)
+            assertsFailed += 1;
+        assertReports.push({ schema: targetSchema, filter, expect, rows: rows.length, ok, ...(ok ? {} : { sample: rows.slice(0, 3) }) });
+    }
+    report.asserts = assertReports;
+    // 5. Cleanup — only rows the fixture names (seed filter), never a blanket key.
+    const cleanups = Array.isArray(fixture.cleanup ?? undefined) ? fixture.cleanup : [];
+    const cleanupReports = [];
+    for (const entry of cleanups) {
+        const spec = (entry.delete ?? {});
+        const targetSchema = String(spec.schema ?? schemaCode);
+        const filter = (spec.filter ?? {});
+        const listed = await callTool("data.list", { environment: session.environmentName, schemaCode: targetSchema, ...filterOf(filter), displayFields: ["name"] }, context);
+        const rows = (listed.rows ?? listed.items ?? []);
+        const ids = rows.map((row) => String(row.bizObjectId ?? row.id ?? "")).filter((id) => id !== "");
+        let deleted = 0;
+        for (const id of ids) {
+            const outcome = await callTool("data.delete", { environment: session.environmentName, schemaCode: targetSchema, bizObjectId: id }, context);
+            if (outcome.status === "ok")
+                deleted += 1;
+        }
+        cleanupReports.push({ schema: targetSchema, filter, matched: ids.length, deleted });
+    }
+    report.cleanup = cleanupReports;
+    const verdict = assertsFailed === 0 ? "pass" : "fail";
+    return {
+        status: "ok",
+        verdict,
+        ...report,
+        ...(verdict === "fail" ? { hint: "断言未命中：核对 fixture.expect 与规则实际写入；规则执行失败会在 trigger 段返回 Java errmsg。" } : {}),
+    };
+}
+//# sourceMappingURL=programming-workflow.js.map