@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/discovery.js

@@ -0,0 +1,390 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { z } from "zod";
+import { LANE_CONTRACTS } from "./contract-resources.js";
+import { intentCapabilityBlock } from "./intent/cli.js";
+import { listSkills } from "./skills.js";
+import { capabilityRouteForTool, capabilityRouteForLane, capabilityRouteIndex, DISCOVERY_AUTHORITY } from "./capability-overview.js";
+/**
+ * `commands --json` — the tool catalogue.
+ *
+ * Round 13 slimmed it. It used to inline `discovery` (the full 14-capability
+ * route projection, ~11.4 KB, byte-identical to `omc capabilities`), and every
+ * tool row repeated `writeGate` (7.5 KB), `timeout` (7.7 KB), and a full
+ * `capability` object (10.5 KB) whose `nickname` == `id` and whose `lane` is
+ * already the row's own lane. That was ~37 KB of repetition in a 56 KB payload
+ * read once and re-sent every later turn. The route projection stays one
+ * command away (`omc capabilities`), and the per-kind governance constants move
+ * to one top-level `governance` block; each row keeps the bare `capability` id
+ * so `--compact --filter/--lane` still matches capabilities.
+ *
+ * `--compact` (round 3) drops the catalogue prose blocks and per-tool example
+ * args, leaving a bounded `purpose` line per tool.
+ */
+export function commandInventory(registry, options = {}) {
+    const routeByLane = capabilityRouteIndex(registry).routeByLane;
+    // One row shape for both modes (round 13). Recipe ids stay on every row: they
+    // let the agent run `describe <tool> --example <id>` (~1–2 KB) instead of
+    // `--full` (16 KB). The row no longer repeats `writeGate`/`timeout` (per-kind
+    // constants, in the top-level `governance` block) or a full `capability`
+    // object (the bare id; `nickname` == `id`, `lane` == the row's own lane,
+    // aliases come from `omc capabilities`).
+    const rows = registry.map((tool) => {
+        const capability = typeof tool.lane === "string" ? routeByLane.get(tool.lane) : undefined;
+        const recipes = (tool.executionMetadata?.recipes ?? []).map((recipe) => recipe.id);
+        return {
+            name: tool.name,
+            lane: tool.lane ?? null,
+            kind: tool.kind,
+            requiredArgs: requiredArgs(tool),
+            ...(capability ? { capability: capability.id } : {}),
+            ...(recipes.length > 0 ? { recipes } : {}),
+        };
+    });
+    if (options.compact === true) {
+        // The machine inventory: rows only, no catalogue prose. `--compact` used to
+        // trade boilerplate for a bounded `purpose` line; with the rows slimmed
+        // (round 13) the prose is the only difference left, so a compact query is
+        // now a strict subset of the full catalogue.
+        return {
+            discovery: { authoritative: DISCOVERY_AUTHORITY.authoritative, route: DISCOVERY_AUTHORITY.route },
+            tools: rows,
+        };
+    }
+    return {
+        // The authoritative route, identical to `omc help` / `omc capabilities`
+        // (ticket-07 pins the four-surface agreement). The heavy part that used to
+        // live here was the 11.4 KB capability projection, byte-identical to `omc
+        // capabilities`; that is now named, not copied.
+        discovery: { ...DISCOVERY_AUTHORITY },
+        // Per-kind constants, stated once (round 13). `kind` on each row is the
+        // discriminator; the write gate applies only to `kind:"write"`.
+        governance: {
+            writeGate: {
+                write: "environment writable permission; production needs confirmProduction",
+                read: "none",
+                governance: "none",
+                meta: "none",
+            },
+            timeout: { behavior: "bounded per call with --timeout-ms; timeout returns uncertain" },
+        },
+        tools: rows,
+        // Ticket 122 (Spec 107): the methodology layer — reachable via `omc help
+        // <topic>`, which lists this same inventory.
+        skills: listSkills(),
+        // Ticket 117 (Spec 107): the declarative usage face — agents discover the
+        // intent layer (families, lifecycle, constraints) here, wire details stay
+        // in the per-tool entries.
+        intent: intentCapabilityBlock(),
+        // Ticket 125: the Configuration capability overview lives one command away;
+        // this is only a pointer so `commands --json` stays a tool catalogue.
+        capabilities: {
+            command: "omc capabilities",
+            detail: "omc capability <id>",
+            note: "capability / order / declarative-coverage overview; not inlined here",
+        },
+    };
+}
+/**
+ * Bare `omc commands` (no `--json`, no `--compact`, no scope): a bounded INDEX,
+ * not the 54 KB catalogue.
+ *
+ * Round 9 heavy-task measurement (sandbox 38): an agent exploring cold ran bare
+ * `commands` 4× at ~54 KB each — ~216 KB, 28% of the whole task — even though
+ * the full rows are the fallback face and `next`/`--compact --lane` exist. The
+ * bytes were paid before any hint could be read. So the DEFAULT face is now the
+ * lean index (name/lane/kind + lane counts + how to expand); the full rows
+ * require the documented machine entry `commands --json`, and one capability is
+ * `commands --json --compact --lane <lane>`.
+ */
+export function commandIndex(registry) {
+    const byLane = new Map();
+    for (const tool of registry) {
+        const lane = tool.lane ?? "(unbound)";
+        byLane.set(lane, (byLane.get(lane) ?? 0) + 1);
+    }
+    return {
+        discovery: { authoritative: DISCOVERY_AUTHORITY.authoritative, route: DISCOVERY_AUTHORITY.route },
+        toolCount: registry.length,
+        lanes: [...byLane.entries()].map(([lane, tools]) => ({ lane, tools })).sort((left, right) => left.lane.localeCompare(right.lane)),
+        tools: registry.map((tool) => ({ name: tool.name, lane: tool.lane ?? null, kind: tool.kind })),
+        hint: "裸 `commands` 是有界索引（name/lane/kind）。全量行用 `omc commands --json`；单能力用 `omc commands --json --compact --lane <lane>`；关键词用 `--filter <word>`；目标→路线优先 `omc next \"<目标>\"`。",
+    };
+}
+const convertToJsonSchema = zodToJsonSchema;
+function jsonSchemaFor(shape) {
+    const objectSchema = z.object(shape);
+    return convertToJsonSchema(objectSchema, { target: "jsonSchema7", $refStrategy: "none" });
+}
+/**
+ * Context-cost projection: the default `describe` must stay small. A tool
+ * contract used to be 14–20 KB (`inputSchema` alone was >50%), and an agent
+ * reading it 19 times paid ~100k tokens for a handful of facts. The compact
+ * form answers "what can I pass, what is required, what is one runnable call"
+ * in ~1–2 KB; the full schema, recipes, and capability route live behind
+ * `describe <tool> --full` and `describe <tool> --param <name>`.
+ */
+/** First sentence, whitespace-collapsed and bounded — enough to pick a tool. */
+function summarizeDescription(description) {
+    const collapsed = description.replace(/\s+/g, " ").trim();
+    const firstStop = collapsed.search(/[。.;；!！?？]/);
+    const sentence = firstStop >= 0 ? collapsed.slice(0, firstStop + 1) : collapsed;
+    return sentence.length > 200 ? `${sentence.slice(0, 197)}...` : sentence;
+}
+/** A terse type label: `string`, `integer`, `array<string>`, `string: A|B`. */
+function terseType(node) {
+    if (!node)
+        return "any";
+    if (Array.isArray(node.enum) && node.enum.length > 0) {
+        const values = node.enum.map((value) => String(value));
+        const label = `${node.type ?? "string"}: ${values.join("|")}`;
+        return label.length > 80 ? `${node.type ?? "string"} (enum)` : label;
+    }
+    if (node.type === "array")
+        return `array<${terseType(node.items)}>`;
+    return node.type ?? "any";
+}
+/** Compact params: `required` list + `param -> type`, no per-param prose. */
+function compactParams(schema) {
+    const required = [...(schema.required ?? [])];
+    const params = {};
+    for (const [key, node] of Object.entries(schema.properties ?? {}))
+        params[key] = terseType(node);
+    return { required, params };
+}
+/**
+ * The example list: every recipe's id/title/status, but none of its args. This
+ * keeps the default `describe` small while still telling the agent which shapes
+ * exist; the full args come from `describe <tool> --example <id>`. A tool with
+ * no recipe says so explicitly and names the precondition rather than returning
+ * a silent `available:false`.
+ */
+function exampleList(tool) {
+    const recipes = tool.executionMetadata?.recipes ?? [];
+    if (recipes.length === 0) {
+        // Read/plain tools have no authored recipe because `required` + `params`
+        // already fully describe the call. Pointing them at `--full` (5–20 KB) made
+        // dogfood agents pay for it anyway (sandbox20: ~10 KB of read-tool --full
+        // calls). Name the cheap faces instead.
+        return [{ requiresPriorReadback: tool.kind === "write", reason: "no authored recipe needed: `required` + `params` above describe the call; per-param prose via --param <name>" }];
+    }
+    return recipes.map((recipe) => ({
+        id: recipe.id,
+        title: recipe.title,
+        status: recipe.status,
+        requiresPriorReadback: recipe.requiresEnvironmentDerivedIds,
+    }));
+}
+/** Default `omc describe`: the compact contract projection. */
+export function describeTool(registry, name) {
+    const tool = registry.find((entry) => entry.name === name);
+    if (!tool)
+        return undefined;
+    const schema = jsonSchemaFor(tool.inputSchema);
+    const { required, params } = compactParams(schema);
+    const examples = exampleList(tool);
+    const hasRecipe = (tool.executionMetadata?.recipes.length ?? 0) > 0;
+    return {
+        name: tool.name,
+        lane: tool.lane ?? null,
+        kind: tool.kind,
+        summary: summarizeDescription(tool.description),
+        required,
+        params,
+        examples,
+        // Point cold callers at the cheap runnable face BEFORE they reach for
+        // --full: a recipe is ~1–2 KB and a single --param is a few hundred bytes,
+        // while --full is 5–20 KB. Benchmark (bench13): two --full calls were 34 KB
+        // of a 133 KB task even though a matching recipe existed.
+        ...(hasRecipe ? { exampleHint: `可运行参数用 --example <id>（~1–2KB）；单参数用 --param <name>；仅当二者都缺形状才 --full` } : {}),
+        ...(!hasRecipe ? { exampleHint: `无静态 recipe：required + params 已够常规调用；单参数说明用 --param <name>；仅当需要全部参数注释/拒绝形状才 --full（5–20KB）` } : {}),
+        // Keep the cost salient at the decision point: agents reached for --full even
+        // when --example/--param existed (sandbox22: 8 --full calls, one 19 KB).
+        full: `omc describe ${tool.name} --full（5–20KB；先试 --example/--param）`,
+    };
+}
+/** `omc describe <tool> --example <id>`: one recipe in full, by id. */
+export function describeExample(registry, name, exampleId) {
+    const tool = registry.find((entry) => entry.name === name);
+    if (!tool)
+        return undefined;
+    const recipes = tool.executionMetadata?.recipes ?? [];
+    const recipe = exampleId === undefined ? undefined : recipes.find((entry) => entry.id === exampleId);
+    if (!recipe) {
+        // No id (or an unknown one) lists the runnable ids instead of a dead end, so
+        // an agent that guessed never burns a retry (sandbox26: `--example` with no
+        // id was a hard commander error; an unknown id already listed `available`).
+        return {
+            name: tool.name,
+            ...(exampleId !== undefined ? { example: exampleId } : {}),
+            found: false,
+            available: recipes.map((entry) => entry.id),
+            ...(recipes[0] ? { hint: `本工具的例子 id 是 ${recipes.map((entry) => entry.id).join("、")}；用 describe ${tool.name} --example ${recipes[0].id} 取可运行参数` } : {}),
+        };
+    }
+    return {
+        name: tool.name,
+        example: recipe.id,
+        title: recipe.title,
+        recipeStatus: recipe.status,
+        tool: recipe.tool,
+        args: recipe.args,
+        command: `omc call ${recipe.tool} --args '<json>'`,
+        preconditions: recipe.preconditions,
+        conditionalRequirements: recipe.conditionalRequirements,
+        priorToolReferences: recipe.priorToolReferences,
+        dryRun: recipe.dryRun,
+        expectedReadback: recipe.expectedReadback,
+        refusalRecovery: recipe.refusalRecovery,
+    };
+}
+/** One param's full schema and prose — the targeted replacement for reading the whole contract. */
+export function describeParam(registry, name, param) {
+    const tool = registry.find((entry) => entry.name === name);
+    if (!tool)
+        return undefined;
+    const schema = jsonSchemaFor(tool.inputSchema);
+    const node = schema.properties?.[param];
+    if (!node) {
+        return { name: tool.name, param, found: false, available: Object.keys(schema.properties ?? {}) };
+    }
+    return {
+        name: tool.name,
+        param,
+        required: (schema.required ?? []).includes(param),
+        type: terseType(node),
+        ...(node.description ? { description: node.description } : {}),
+        schema: node,
+    };
+}
+/**
+ * `omc describe <tool> --full`: the complete contract (schema, capability route).
+ *
+ * Round 13: `--full` used to also inline `executionMetadata` — the whole recipe
+ * set with full args, expectedReadback and refusalRecovery (7–8 KB for
+ * field.create / rule.save). That is reachable two cheaper ways already: the
+ * default `describe` lists the recipe ids, and `describe <tool> --example <id>`
+ * returns one recipe in ~1–2 KB. `commands --json` also carries the per-tool
+ * recipe ids. Bench (bench35 sandbox): a 77 k peak task spent 70 KB on four
+ * `describe --full` calls, of which the recipes were ~30 KB. `--full` now names
+ * the recipe ids (in `recipeIds`) and leaves the args to `--example`.
+ */
+export function describeToolFull(registry, name) {
+    const tool = registry.find((entry) => entry.name === name);
+    if (!tool)
+        return undefined;
+    const schema = jsonSchemaFor(tool.inputSchema);
+    const recipes = tool.executionMetadata?.recipes ?? [];
+    const recipe = recipes[0];
+    const capability = capabilityRouteForTool(registry, tool.name);
+    return {
+        name: tool.name,
+        lane: tool.lane ?? null,
+        kind: tool.kind,
+        description: tool.description,
+        ...(capability ? { capability } : {}),
+        inputSchema: schema,
+        // Recipe ids only — the args live behind `--example <id>` (round 13). This
+        // keeps `--full` to its job (the schema + prose) instead of re-shipping the
+        // recipe set the default face and `--example` already cover.
+        ...(recipes.length > 0 ? { recipeIds: recipes.map((entry) => entry.id) } : {}),
+        // --full is 5–20 KB. When the tool has runnable recipes, remind the caller
+        // (bench17 still pulled 18 KB of field.create --full and 8 KB of
+        // workflow.update --full although matching recipes existed) that the recipe
+        // is the cheaper, authoritative shape.
+        ...(recipes.length > 0
+            ? { recipeHint: `本工具已有可运行 recipe（${recipes.map((entry) => entry.id).join("、")}）；用 --example <id>（~1–2KB）取可运行参数，不要在 --full 里找` }
+            : {}),
+        example: recipe
+            ? {
+                command: `omc call ${recipe.tool} --args '<json>'`,
+                tool: recipe.tool,
+                args: recipe.args,
+                recipeId: recipe.id,
+                status: recipe.status,
+            }
+            : {
+                tool: tool.name,
+                available: false,
+                reason: "no scenario-specific recipe; use inputSchema and discover prerequisites before execution",
+            },
+    };
+}
+/** `omc describe <tool> --schema-only`: the raw JSON schema, nothing else. */
+export function describeSchemaOnly(registry, name) {
+    const tool = registry.find((entry) => entry.name === name);
+    if (!tool)
+        return undefined;
+    return { name: tool.name, inputSchema: jsonSchemaFor(tool.inputSchema) };
+}
+/**
+ * `omc contract <lane>` — the compact default: who the lane binds, which tools
+ * it owns, and the wire structure's key outline. The full wire payload (14–23 KB)
+ * lives behind `--full`; most of the time an agent needs the tool names and the
+ * shape's top-level keys, not the nested bodies.
+ */
+export function describeContract(registry, lane) {
+    const contract = LANE_CONTRACTS.find((entry) => entry.lane === lane);
+    if (!contract)
+        return undefined;
+    const route = capabilityRouteForLane(registry, contract.lane);
+    return {
+        contract: {
+            lane: contract.lane,
+            family: contract.family,
+            referenceVersion: contract.referenceVersion,
+            tools: Object.keys(contract.tools),
+            wireKeys: Object.keys(contract.wire),
+            endpointKeys: Object.keys(contract.endpoints),
+            ...(route ? { capability: { nickname: route.nickname, id: route.id, lane: route.lane, aliases: route.aliases } } : {}),
+            full: `omc contract ${contract.lane} --full`,
+        },
+    };
+}
+/** `omc contract <lane> --full`: the complete wire contract. */
+export function describeContractFull(registry, lane) {
+    const contract = LANE_CONTRACTS.find((entry) => entry.lane === lane);
+    if (!contract)
+        return undefined;
+    const route = capabilityRouteForLane(registry, contract.lane);
+    const shape = {
+        lane: contract.lane,
+        family: contract.family,
+        referenceVersion: contract.referenceVersion,
+        endpoints: contract.endpoints,
+        wire: contract.wire,
+        tools: contract.tools,
+        ...(route ? { capability: route } : {}),
+    };
+    return { contract: shape };
+}
+/**
+ * `omc contract <lane> --tool <name>` (round 3): one tool's authored lane
+ * contract slice. An agent that already knows the tool should not pull the
+ * whole 14–23 KB lane contract (the `tools` block alone is ~10 KB of prose).
+ * A missing tool names the available ones instead of silently returning empty.
+ */
+export function describeContractTool(registry, lane, toolName) {
+    const contract = LANE_CONTRACTS.find((entry) => entry.lane === lane);
+    if (!contract)
+        return undefined;
+    const tool = contract.tools[toolName];
+    if (!tool) {
+        return { contract: { lane: contract.lane, family: contract.family, referenceVersion: contract.referenceVersion, tool: toolName, found: false, available: Object.keys(contract.tools) } };
+    }
+    const route = capabilityRouteForLane(registry, contract.lane);
+    return {
+        contract: {
+            lane: contract.lane,
+            family: contract.family,
+            referenceVersion: contract.referenceVersion,
+            tool: { name: toolName, scope: tool.scope, description: tool.description },
+            ...(route ? { capability: { nickname: route.nickname, id: route.id, lane: route.lane, aliases: route.aliases } } : {}),
+            full: `omc contract ${contract.lane} --full`,
+        },
+    };
+}
+function requiredArgs(tool) {
+    const schema = jsonSchemaFor(tool.inputSchema);
+    return schema.required ?? [];
+}
+//# sourceMappingURL=discovery.js.map

package/dist/endpoints.js

@@ -0,0 +1,154 @@
+/**
+ * Live-proven CloudPivot 8.6 wire endpoints (from the M1 coverage manifest
+ * evidence chains). Every low-level tool drives exactly these paths — no
+ * invented surfaces.
+ */
+export const ENDPOINTS = {
+    applicationList: "/api/api/app/apppackage/list",
+    applicationGroupList: "/api/api/app/apppackage/list_all_group",
+    applicationGet: "/api/api/app/apppackage/get",
+    applicationCreate: "/api/api/app/apppackage/create",
+    applicationUpdate: "/api/api/app/apppackage/update",
+    applicationDelete: "/api/api/app/apppackage/delete",
+    applicationTree: "/api/api/app/apppackage/trees",
+    modelList: "/api/api/app/bizmodels/list_schema",
+    modelGet: "/api/api/app/bizmodels/get_all",
+    modelCreate: "/api/api/app/bizmodels/create",
+    modelGetSummary: "/api/api/app/bizmodels/get_summary",
+    modelUpdateSummary: "/api/api/app/bizmodels/update_summary",
+    modelUpdate: "/api/api/app/bizmodels/update",
+    appPackagePhysicallyDelete: "/api/api/app/apppackage/physically_delete",
+    fieldList: "/api/api/app/bizproperty/list",
+    fieldGet: "/api/api/app/bizproperty/get",
+    fieldCreate: "/api/api/app/bizproperty/create",
+    fieldUpdate: "/api/api/app/bizproperty/update",
+    fieldPublish: "/api/api/app/bizproperty/publish",
+    fieldDelete: "/api/api/app/bizproperty/delete",
+    fieldForceDelete: "/api/api/app/bizproperty/force_delete",
+    dictionarySearch: "/api/api/data_dictionary/searchDictionary",
+    dictionaryGet: "/api/api/data_dictionary/getDictionaryById",
+    dictionaryGetByCode: "/api/api/data_dictionary/getDictionaryByCode",
+    dictionaryGetByType: "/api/api/data_dictionary/getDictionaryByType",
+    dictionaryIdAndNames: "/api/api/data_dictionary/getDictionaryIdAndNames",
+    dictionarySave: "/api/api/data_dictionary/saveDictionary",
+    dictionaryUpdateStatus: "/api/api/data_dictionary/updateDictionaryStatus",
+    dictionaryRecords: "/api/api/data_dictionary/searchDictionaryRecord",
+    dictionaryRecordsByCode: "/api/api/data_dictionary/searchDictionaryRecordByCode",
+    dictionaryEnabledRecords: "/api/api/data_dictionary/getEnableRecordsByDictionaryId",
+    dictionaryEnabledRecordsByCode: "/api/api/data_dictionary/getEnableRecordsByDictionaryCode",
+    dictionaryParentRecords: "/api/api/data_dictionary/getDictionaryRecordByParentId",
+    dictionaryRecordStatus: "/api/api/data_dictionary/updateDictionaryRecordStatus",
+    dictionaryRecordUsed: "/api/api/data_dictionary/updateDictionaryRecordUsed",
+    dictionaryClasses: "/api/api/data_dictionary/getDictionaryClass",
+    dictionaryClassDetail: "/api/api/data_dictionary/getDictionaryClassDetail",
+    dictionaryClassSave: "/api/api/data_dictionary/saveDictionaryClass",
+    dictionaryClassDelete: "/api/api/data_dictionary/deleteDictionaryClass",
+    dictionaryClassDeleteBatch: "/api/api/data_dictionary/deleteDictionaryClassBatch",
+    sheetGet: "/api/api/app/bizsheet/get",
+    sheetCreate: "/api/api/app/bizsheet/create",
+    sheetUpdate: "/api/api/app/bizsheet/update",
+    sheetPublish: "/api/api/app/bizsheet/publish",
+    sheetHistoryList: "/api/api/app/bizsheet/history/list",
+    businessRuleListBySchemaCode: "/api/api/app/businessrule/list_by_schemacode",
+    runtimeBusinessRuleListBySchemaCode: "/api/api/runtime/business_rule/list_by_schemacode",
+    businessRuleGet: "/api/api/app/businessrule/get",
+    businessRuleCreate: "/api/api/app/businessrule/create",
+    businessRuleUpdate: "/api/api/app/businessrule/update",
+    businessRulePublish: "/api/api/app/businessrule/publish",
+    businessRuleEnable: "/api/api/app/businessrule/enable",
+    businessRuleDelete: "/api/api/app/businessrule/delete",
+    dataRuleCreate: "/api/api/app/bizdatarule/create",
+    dataRuleList: "/api/api/app/bizdatarule/list",
+    dataRuleUpdate: "/api/api/app/bizdatarule/update",
+    dataRuleDelete: "/api/api/app/bizdatarule/delete",
+    runtimeFormSave: "/api/api/runtime/form/save",
+    runtimeFormLoad: "/api/api/runtime/form/load",
+    runtimeFormReplayToken: "/api/api/runtime/form/getReplayToken",
+    runtimeQueryList: "/api/api/runtime/query/list",
+    runtimeFormDelete: "/api/api/runtime/form/delete",
+    runtimeFormSubmit: "/api/api/runtime/form/submit",
+    bizServiceCreate: "/api/api/bizservice/service/create",
+    bizServiceUpdate: "/api/api/bizservice/service/update",
+    bizServiceGetByCode: "/api/api/bizservice/service/get_by_code",
+    bizServiceCategoryList: "/api/api/bizservice/category/list",
+    bizServiceCategoryCreate: "/api/api/bizservice/category/create",
+    bizServiceCategoryUpdate: "/api/api/bizservice/category/update",
+    bizServiceCategoryDelete: "/api/api/bizservice/category/delete",
+    bizDbConnPoolList: "/api/api/bizservice/dbconnpool/list",
+    bizDbConnPoolCreate: "/api/api/bizservice/dbconnpool/create",
+    bizDbConnPoolUpdate: "/api/api/bizservice/dbconnpool/update",
+    bizDbConnPoolDelete: "/api/api/bizservice/dbconnpool/delete",
+    bizServiceAdapterConfig: "/api/api/bizservice/service/adapter_config",
+    bizServiceTableList: "/api/api/bizservice/method/get_tablename_list",
+    bizServiceTableSql: "/api/api/bizservice/method/get_table_column",
+    bizServiceMethodCreate: "/api/api/bizservice/method/create",
+    bizServiceMethodUpdate: "/api/api/bizservice/method/update",
+    bizServiceMethodGet: "/api/api/bizservice/method/get",
+    bizServiceMethodDelete: "/api/api/bizservice/method/delete",
+    bizServiceMethodTest: "/api/api/bizservice/method/service_test",
+    bizServiceMethodList: "/api/api/bizservice/method/list_by_service_code",
+    bizServiceDelete: "/api/api/bizservice/service/delete",
+    bizServiceExport: "/api/api/bizservice/service/export",
+    bizServiceCheck: "/api/api/bizservice/service/check",
+    bizServiceImport: "/api/api/bizservice/service/import",
+    runtimeQueryUploadFile: "/api/api/runtime/query/upload_file",
+    // `/api/api/programming/*` (design-time 在线开发: business-rule / SPI /
+    // service-component JAVA source) is deliberately NOT wrapped. It is backend
+    // Java authored through 二开扩展包, not form Online JS, and no operator asked
+    // for it here — so the CLI exposes no tool for it. Live 2026-09-21 evidence
+    // (ProgrammingController.java:99, base is the doubled `/api/api/programming`
+    // under the `/api` context-path; the earlier single-`/api` form 404s) is
+    // recorded in the online-js contract's history note.
+    workflowCreate: "/api/api/workflow/create",
+    workflowGetHeader: "/api/api/workflow/get_header",
+    workflowGetDraft: "/api/api/workflow/get_draft",
+    workflowIsWorkflow: "/api/api/workflow/isworkflow",
+    workflowGetBySchema: "/api/api/workflow/getWorkflow",
+    workflowGetPublished: "/api/api/workflow/get_published",
+    workflowUpdate: "/api/api/workflow/update",
+    workflowValidate: "/api/api/workflow/validate",
+    workflowPublish: "/api/api/workflow/publish",
+    workflowDelete: "/api/api/workflow/delete",
+    workflowSearchWorkItems: "/api/api/runtime/workflow/search_workitems",
+    workflowGetBizObjectByWfInstanceId: "/api/api/runtime/workflow/getBizObjectByWfInstanceId",
+    organizationRoleList: "/api/api/organization/role/list",
+    organizationDepartmentTree: "/api/api/organization/department/tree",
+    organizationUserSearch: "/api/api/organization/user/search",
+    listQueryCreate: "/api/api/app/query/create",
+    listQueryGet: "/api/api/app/query/get",
+    listQueryUpdate: "/api/api/app/query/update",
+    listQueryUpdateHeader: "/api/api/app/query/update_header",
+    listQueryGetHeader: "/api/api/app/query/get_header",
+    listQueryList: "/api/api/app/query/list",
+    listQueryDelete: "/api/api/app/query/delete",
+    // R1-report — design-time report pages live on the platform channel
+    // (`/api/api/report/*`, errcode envelope); the BI chart/dashboard face lives
+    // on the separate `/dashboard/v1/*` channel (no errcode envelope; auth is a
+    // `config` object carried in the request body). Both are live-proven on the
+    // aozhe tenant (AI-Platform-v1.1.22, engineCode aozhe).
+    reportTreeAll: "/api/api/app/folders/queryReportChartTree",
+    reportTreeByApp: "/api/api/runtime/app/queryReportChartTreeByApp",
+    reportGet: "/api/api/report/get",
+    reportFrontGet: "/api/api/report/frontget",
+    reportCreate: "/api/api/report/create",
+    reportUpdate: "/api/api/report/update",
+    reportDelete: "/api/api/report/logical_delete",
+    biReportConfig: "/dashboard/v1/report/v2/config",
+    biReportPageSave: "/dashboard/v1/report/v2/reportpage",
+    biReportRemove: "/dashboard/v1/report/removeReport",
+    biReportSaveGlobal: "/dashboard/v1/report/saveGlobal",
+    biReportSaveAttributes: "/dashboard/v1/report/saveAttributes",
+    biReportGlobalFilters: "/dashboard/v1/report/local_global_filters",
+    biChartAdd: "/dashboard/v1/chart/addChart",
+    biChartUpdate: "/dashboard/v1/chart/updateChart",
+    biChartRemove: "/dashboard/v1/chart/removeChart",
+    biChartRemoveMany: "/dashboard/v1/chart/removeCharts",
+    biChartUpdateTitle: "/dashboard/v1/chart/updateTitle",
+    biChartUpdatePositions: "/dashboard/v1/chart/updatePositions",
+    biChartData: "/dashboard/v1/datalogic/v3/chartdata",
+    biDatasourceModelList: "/dashboard/v1/report/v3/datasourcelist",
+    biDatasourceModelLink: "/dashboard/v1/report/v3/datasource",
+    biDatasourceAdvancedList: "/dashboard/datasource/advanced_list",
+    biDatasourceList: "/dashboard/datasource/v2/datasource_list",
+};
+//# sourceMappingURL=endpoints.js.map

package/dist/environment-policy.js

@@ -0,0 +1,26 @@
+/** The environment's write permission: the single machine-side write gate. */
+export function environmentWritable(profile) {
+    return profile.writable === true;
+}
+export function environmentKind(profile) {
+    return profile.production === true ? "生产环境" : "测试环境";
+}
+/**
+ * A production environment is a high-risk write target: writable exactly like
+ * any other, but every write must carry an explicit per-write confirmation that
+ * is recorded in the audit artifact. The mark is a risk label, not a gate.
+ */
+export function requiresProductionConfirmation(profile) {
+    return profile.production === true;
+}
+export function environmentNotice(profile) {
+    if (profile.production === true) {
+        return environmentWritable(profile)
+            ? "当前是生产环境；写入前必须逐笔携带显式高危确认（confirmProduction:true），确认会记入审计工件。"
+            : "当前是生产环境；当前设置为只读，写入会被拒绝。";
+    }
+    return environmentWritable(profile)
+        ? "当前是测试环境；已允许写入，仅应使用测试数据。"
+        : "当前是测试环境；当前设置为只读，写入会被拒绝。";
+}
+//# sourceMappingURL=environment-policy.js.map