@thinkingai/ae-cli 6.0.48 → 6.1.0-project-role-upsert.1

package/dist/te-experiment-ESEYE2SK.js

@@ -0,0 +1,1059 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  createCapabilityCommand
+} from "./chunk-JDPEVVHR.js";
+import "./chunk-QJQZH5GQ.js";
+import {
+  registerCapabilityGatewayRoute
+} from "./chunk-TKHSULJT.js";
+import "./chunk-CZU3V3DQ.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-ATSM5XAW.js";
+import "./chunk-WZ6YVQSF.js";
+import "./chunk-4P355ZWB.js";
+
+// src/commands/te-experiment/capability-shared.ts
+function createExperimentCapabilityCommand(config) {
+  return createCapabilityCommand({
+    ...config,
+    cliService: "experiment",
+    gatewayDomain: "engage"
+  });
+}
+function readRequiredObject(ctx, name) {
+  const value = ctx.json(name);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Flag --${name} must be a JSON object`);
+  }
+  return value;
+}
+function readRequiredStringArray(ctx, name) {
+  const value = ctx.json(name);
+  if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string" && item.length > 0)) {
+    throw new Error(`Flag --${name} must be a non-empty JSON array of strings`);
+  }
+  return value;
+}
+function addOptionalString(input, name, value) {
+  if (value !== "") input[name] = value;
+}
+function addOptionalBoolean(input, ctx, flagName, fieldName) {
+  if (ctx.str(flagName) !== "") input[fieldName] = ctx.bool(flagName);
+}
+
+// src/commands/te-experiment/bucket/list.ts
+var bucketList = createExperimentCapabilityCommand({
+  resource: "bucket",
+  command: "list",
+  capabilityId: "experiment.bucket.list",
+  description: "List split buckets in a project.",
+  flags: [{ name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id") })
+});
+
+// src/commands/te-experiment/experiment/batch-delete.ts
+var experimentBatchDelete = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "batch-delete",
+  capabilityId: "experiment.experiment.batch-delete",
+  description: "Batch delete experiments.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-ids", type: "json", required: true, desc: "Experiment IDs as a JSON string array." }
+  ],
+  risk: "high-risk-write",
+  validate: (ctx) => {
+    readRequiredStringArray(ctx, "exp-ids");
+  },
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    exp_ids: readRequiredStringArray(ctx, "exp-ids")
+  })
+});
+
+// src/commands/te-experiment/experiment/conflict-check.ts
+function buildInput(ctx) {
+  const input = {
+    project_id: ctx.num("project-id"),
+    feature_key_list: readRequiredStringArray(ctx, "feature-key-list"),
+    traffic_layer_id: ctx.str("traffic-layer-id")
+  };
+  addOptionalString(input, "exp_id", ctx.str("exp-id"));
+  return input;
+}
+var experimentConflictCheck = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "conflict-check",
+  capabilityId: "experiment.experiment.conflict-check",
+  description: "Pre-submit check for cross-layer Feature conflicts on a non-mutex traffic layer.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    {
+      name: "feature-key-list",
+      type: "json",
+      required: true,
+      desc: "Feature keys selected by the current experiment as a JSON string array."
+    },
+    {
+      name: "traffic-layer-id",
+      type: "string",
+      required: true,
+      desc: "Selected non-mutex traffic layer ID."
+    },
+    {
+      name: "exp-id",
+      type: "string",
+      required: false,
+      desc: "Current experiment ID when editing an existing draft."
+    }
+  ],
+  risk: "read",
+  validate: (ctx) => {
+    readRequiredStringArray(ctx, "feature-key-list");
+    if (ctx.str("traffic-layer-id") === "") {
+      throw new Error("Flag --traffic-layer-id is required");
+    }
+  },
+  buildInput
+});
+
+// src/commands/te-experiment/experiment/get.ts
+var experimentGet = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "get",
+  capabilityId: "experiment.experiment.get",
+  description: "Get one experiment by ID.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), exp_id: ctx.str("exp-id") })
+});
+
+// src/commands/te-experiment/experiment/list.ts
+function buildInput2(ctx) {
+  const input = {
+    project_id: ctx.num("project-id")
+  };
+  addOptionalString(input, "status", ctx.str("status"));
+  addOptionalString(input, "traffic_layer_id", ctx.str("traffic-layer-id"));
+  addOptionalString(input, "group_id", ctx.str("group-id"));
+  addOptionalString(input, "query_name", ctx.str("query-name"));
+  return input;
+}
+var experimentList = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "list",
+  capabilityId: "experiment.experiment.list",
+  description: "List experiments in a project with optional status, traffic layer, group, and name filters.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    {
+      name: "status",
+      type: "string",
+      required: false,
+      desc: "Experiment status filter: draft, testing, pending, running, paused, ended, or archive."
+    },
+    {
+      name: "traffic-layer-id",
+      type: "string",
+      required: false,
+      desc: "Traffic layer ID filter."
+    },
+    {
+      name: "group-id",
+      type: "string",
+      required: false,
+      desc: "Business group ID filter."
+    },
+    {
+      name: "query-name",
+      type: "string",
+      required: false,
+      desc: "Fuzzy match against experiment name (exp_name LIKE)."
+    }
+  ],
+  risk: "read",
+  buildInput: buildInput2
+});
+
+// src/commands/te-experiment/experiment/list-archived.ts
+var experimentListArchived = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "list-archived",
+  capabilityId: "experiment.experiment.list-archived",
+  description: "List archived experiments in a project.",
+  flags: [{ name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id") })
+});
+
+// src/commands/te-experiment/experiment/manage.ts
+var targetStatuses = ["draft", "testing", "pending", "running", "paused", "ended", "archive"];
+function buildInput3(ctx) {
+  const input = {
+    project_id: ctx.num("project-id"),
+    exp_id: ctx.str("exp-id"),
+    target_status: ctx.str("target-status")
+  };
+  addOptionalString(input, "remark", ctx.str("remark"));
+  return input;
+}
+var experimentManage = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "manage",
+  capabilityId: "experiment.experiment.manage",
+  description: "Update an experiment status.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment ID." },
+    { name: "target-status", type: "string", required: true, desc: "Target experiment status." },
+    { name: "remark", type: "string", required: false, desc: "Operation remark." }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    const value = ctx.str("target-status");
+    if (!targetStatuses.includes(value)) {
+      throw new Error(`Flag --target-status must be one of: ${targetStatuses.join(", ")}`);
+    }
+  },
+  buildInput: buildInput3
+});
+
+// src/commands/te-experiment/experiment/ready-check.ts
+var experimentReadyCheck = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "ready-check",
+  capabilityId: "experiment.experiment.ready-check",
+  description: "Check whether an experiment is ready for an online status transition.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), exp_id: ctx.str("exp-id") })
+});
+
+// src/commands/te-experiment/experiment/save.ts
+var experimentSave = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "save",
+  capabilityId: "experiment.experiment.save",
+  description: "Create or update an experiment draft.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    {
+      name: "req",
+      type: "json",
+      required: true,
+      desc: "Native camelCase request; custom audiences use targeting.definitionRequest, never targetConfig."
+    }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    readRequiredObject(ctx, "req");
+  },
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredObject(ctx, "req") })
+});
+
+// src/commands/te-experiment/experiment/update-group.ts
+var experimentUpdateGroup = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "update-group",
+  capabilityId: "experiment.experiment.update-group",
+  description: "Update the business group of one experiment.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment ID." },
+    {
+      name: "group-id",
+      type: "string",
+      required: true,
+      desc: 'Target business group ID. Use "0" for ungrouped.'
+    }
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    exp_id: ctx.str("exp-id"),
+    group_id: ctx.str("group-id")
+  })
+});
+
+// src/commands/te-experiment/experiment/update-metrics.ts
+var METRIC_ROLES = /* @__PURE__ */ new Set(["primary", "secondary", "guardrail"]);
+function readMetricBindings(ctx) {
+  const value = ctx.json("metrics");
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("Flag --metrics must be a non-empty JSON array");
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const item = value[index];
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new Error(`Flag --metrics[${index}] must be a JSON object`);
+    }
+    const metricId = item.metricId;
+    const metricRole = item.metricRole;
+    if (typeof metricId !== "string" || metricId.trim() === "") {
+      throw new Error(`Flag --metrics[${index}].metricId must be a non-empty string`);
+    }
+    if (typeof metricRole !== "string" || !METRIC_ROLES.has(metricRole)) {
+      throw new Error(`Flag --metrics[${index}].metricRole must be one of primary, secondary, guardrail`);
+    }
+  }
+  return value;
+}
+var experimentUpdateMetrics = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "update-metrics",
+  capabilityId: "experiment.experiment.save",
+  description: "Replace experiment metric bindings and assign primary, secondary, or guardrail roles.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment draft ID." },
+    {
+      name: "metrics",
+      type: "json",
+      required: true,
+      desc: "Non-empty metric binding array with camelCase metricId and metricRole fields; replaces all saved bindings."
+    }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    readMetricBindings(ctx);
+  },
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    req: { expId: ctx.str("exp-id"), metrics: readMetricBindings(ctx) }
+  })
+});
+
+// src/commands/te-experiment/feature/batch-delete.ts
+var featureBatchDelete = createExperimentCapabilityCommand({
+  resource: "feature",
+  command: "batch-delete",
+  capabilityId: "experiment.feature.batch-delete",
+  description: "Batch delete Features.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "req", type: "json", required: true, desc: "Native camelCase Feature delete request object." }
+  ],
+  risk: "high-risk-write",
+  validate: (ctx) => {
+    readRequiredObject(ctx, "req");
+  },
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredObject(ctx, "req") })
+});
+
+// src/commands/te-experiment/feature/get.ts
+function buildInput4(ctx) {
+  const input = {
+    project_id: ctx.num("project-id"),
+    feature_key: ctx.str("feature-key")
+  };
+  addOptionalString(input, "version", ctx.str("version"));
+  return input;
+}
+var featureGet = createExperimentCapabilityCommand({
+  resource: "feature",
+  command: "get",
+  capabilityId: "experiment.feature.get",
+  description: "Get one Feature by key and optional version.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "feature-key", type: "string", required: true, desc: "Feature key." },
+    { name: "version", type: "string", required: false, desc: "Feature version ID." }
+  ],
+  risk: "read",
+  buildInput: buildInput4
+});
+
+// src/commands/te-experiment/feature/list.ts
+var featureList = createExperimentCapabilityCommand({
+  resource: "feature",
+  command: "list",
+  capabilityId: "experiment.feature.list",
+  description: "List Features in a project.",
+  flags: [{ name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id") })
+});
+
+// src/commands/te-experiment/feature/save.ts
+var featureSave = createExperimentCapabilityCommand({
+  resource: "feature",
+  command: "save",
+  capabilityId: "experiment.feature.save",
+  description: "Create or update a Feature.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "req", type: "json", required: true, desc: "Native camelCase Feature save request object." }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    readRequiredObject(ctx, "req");
+  },
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredObject(ctx, "req") })
+});
+
+// src/commands/te-experiment/feature/update-status.ts
+var featureUpdateStatus = createExperimentCapabilityCommand({
+  resource: "feature",
+  command: "update-status",
+  capabilityId: "experiment.feature.update-status",
+  description: "Update a Feature status.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "req", type: "json", required: true, desc: "Native camelCase Feature status request object." }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    readRequiredObject(ctx, "req");
+  },
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredObject(ctx, "req") })
+});
+
+// src/commands/te-experiment/feature/version-list.ts
+var featureVersionList = createExperimentCapabilityCommand({
+  resource: "feature",
+  command: "version-list",
+  capabilityId: "experiment.feature.version-list",
+  description: "List Feature version history for one Feature key.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "feature-key", type: "string", required: true, desc: "Feature key." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    feature_key: ctx.str("feature-key")
+  })
+});
+
+// src/commands/te-experiment/feature/operation-log/query.ts
+var featureOperationLogQuery = createExperimentCapabilityCommand({
+  resource: "feature operation-log",
+  command: "query",
+  capabilityId: "experiment.feature.operation-log.query",
+  description: "Query Feature operation logs for one Feature key.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "feature-key", type: "string", required: true, desc: "Feature key." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    feature_key: ctx.str("feature-key")
+  })
+});
+
+// src/commands/te-experiment/feature-whitelist/shared.ts
+function readRuleIds(ctx) {
+  const value = ctx.json("rule-ids");
+  if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string" && item.trim() !== "")) {
+    throw new Error("Flag --rule-ids must be a non-empty JSON array of strings");
+  }
+  return value;
+}
+function readWhitelist(ctx) {
+  const value = ctx.json("whitelist");
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("Flag --whitelist must be a non-empty JSON array");
+  }
+  const bucketIds = /* @__PURE__ */ new Set();
+  value.forEach((bucket, bucketIndex) => {
+    if (!bucket || typeof bucket !== "object" || Array.isArray(bucket)) {
+      throw new Error(`Flag --whitelist[${bucketIndex}] must be a JSON object`);
+    }
+    const item = bucket;
+    if (typeof item.bucket_id !== "string" || item.bucket_id.trim() === "") {
+      throw new Error(`Flag --whitelist[${bucketIndex}].bucket_id must be a non-empty string`);
+    }
+    if (bucketIds.has(item.bucket_id)) {
+      throw new Error(`Flag --whitelist contains duplicate bucket_id: ${item.bucket_id}`);
+    }
+    bucketIds.add(item.bucket_id);
+    if (!Array.isArray(item.rules) || item.rules.length === 0) {
+      throw new Error(`Flag --whitelist[${bucketIndex}].rules must be a non-empty array`);
+    }
+    const bucketValueIds = /* @__PURE__ */ new Set();
+    item.rules.forEach((rule, ruleIndex) => {
+      if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+        throw new Error(`Flag --whitelist[${bucketIndex}].rules[${ruleIndex}] must be a JSON object`);
+      }
+      const row = rule;
+      if (!Array.isArray(row.ids) || row.ids.length === 0 || !row.ids.every((id) => typeof id === "string" && id.trim() !== "")) {
+        throw new Error(`Flag --whitelist[${bucketIndex}].rules[${ruleIndex}].ids must be a non-empty string array`);
+      }
+      row.ids.forEach((id) => {
+        if (bucketValueIds.has(id)) {
+          throw new Error(`Flag --whitelist bucket ${item.bucket_id} contains duplicate ID: ${id}`);
+        }
+        bucketValueIds.add(id);
+      });
+      if (typeof row.value !== "string") {
+        throw new Error(`Flag --whitelist[${bucketIndex}].rules[${ruleIndex}].value must be a string`);
+      }
+    });
+  });
+  return value;
+}
+
+// src/commands/te-experiment/feature-whitelist/batch-delete.ts
+function buildBody(ctx) {
+  return { project_id: ctx.num("project-id"), rule_ids: readRuleIds(ctx) };
+}
+var featureWhitelistBatchDelete = createExperimentCapabilityCommand({
+  resource: "feature whitelist",
+  command: "batch-delete",
+  capabilityId: "experiment.feature_whitelist.batch_delete",
+  description: "Delete Feature whitelist rules; enabled whitelist rules are allowed and trigger RCC resync.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "rule-ids", type: "json", required: true, desc: "Non-empty JSON array of whitelist rule IDs." }
+  ],
+  risk: "high-risk-write",
+  validate: (ctx) => {
+    buildBody(ctx);
+  },
+  buildInput: buildBody
+});
+
+// src/commands/te-experiment/feature-whitelist/list.ts
+function buildInput5(ctx) {
+  return {
+    project_id: ctx.num("project-id"),
+    feature_key: ctx.str("feature-key")
+  };
+}
+var featureWhitelistList = createExperimentCapabilityCommand({
+  resource: "feature whitelist",
+  command: "list",
+  capabilityId: "experiment.feature_whitelist.list",
+  description: "List explicit whitelist rules for one Feature.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "feature-key", type: "string", required: true, desc: "Existing Feature key." }
+  ],
+  risk: "read",
+  buildInput: buildInput5
+});
+
+// src/commands/te-experiment/feature-whitelist/save.ts
+function buildInput6(ctx) {
+  const ruleId = ctx.str("rule-id").trim();
+  const status = ctx.str("status").trim() || "draft";
+  if (!["draft", "enable", "disable"].includes(status)) {
+    throw new Error("Flag --status must be one of draft, enable, disable");
+  }
+  const input = {
+    project_id: ctx.num("project-id"),
+    feature_key: ctx.str("feature-key"),
+    whitelist: readWhitelist(ctx),
+    status
+  };
+  if (ruleId) input.rule_id = ruleId;
+  const priority = ctx.str("priority");
+  if (priority !== "") input.priority = ctx.num("priority");
+  return input;
+}
+var featureWhitelistSave = createExperimentCapabilityCommand({
+  resource: "feature whitelist",
+  command: "save",
+  capabilityId: "experiment.feature_whitelist.save",
+  description: "Create or modify a Feature whitelist rule and optionally enable it.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "feature-key", type: "string", required: true, desc: "Existing Feature key." },
+    { name: "rule-id", type: "string", desc: "Existing whitelist rule ID; omit to create a new rule." },
+    { name: "priority", type: "number", desc: "Rule priority; omitted create requests use the server-assigned next priority." },
+    { name: "status", type: "string", default: "draft", desc: "Rule status: draft, enable, or disable." },
+    {
+      name: "whitelist",
+      type: "json",
+      required: true,
+      desc: 'Whitelist bucket array: [{"bucket_id":"#user_id","rules":[{"ids":["u1"],"value":"on"}]}].'
+    }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    buildInput6(ctx);
+  },
+  buildInput: buildInput6
+});
+
+// src/commands/te-experiment/feature-whitelist/update-status.ts
+function buildBody2(ctx) {
+  const status = ctx.str("status");
+  if (!["enable", "disable"].includes(status)) {
+    throw new Error("Flag --status must be one of enable, disable");
+  }
+  return { project_id: ctx.num("project-id"), rule_id: ctx.str("rule-id"), status };
+}
+var featureWhitelistUpdateStatus = createExperimentCapabilityCommand({
+  resource: "feature whitelist",
+  command: "update-status",
+  capabilityId: "experiment.feature_whitelist.update_status",
+  description: "Enable or disable a Feature whitelist rule; enabled rules sync an online Feature to RCC.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "rule-id", type: "string", required: true, desc: "Whitelist rule ID." },
+    { name: "status", type: "string", required: true, desc: "Target status: enable or disable." }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    buildBody2(ctx);
+  },
+  buildInput: buildBody2
+});
+
+// src/commands/te-experiment/metric/delete.ts
+var metricDelete = createExperimentCapabilityCommand({
+  resource: "metric",
+  command: "delete",
+  capabilityId: "experiment.metric.delete",
+  description: "Delete one experiment metric.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "metric-id", type: "string", required: true, desc: "Metric ID." }
+  ],
+  risk: "high-risk-write",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), metric_id: ctx.str("metric-id") })
+});
+
+// src/commands/te-experiment/metric/get.ts
+var metricGet = createExperimentCapabilityCommand({
+  resource: "metric",
+  command: "get",
+  capabilityId: "experiment.metric.get",
+  description: "Get one experiment metric by ID.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "metric-id", type: "string", required: true, desc: "Metric ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), metric_id: ctx.str("metric-id") })
+});
+
+// src/commands/te-experiment/metric/list.ts
+var metricList = createExperimentCapabilityCommand({
+  resource: "metric",
+  command: "list",
+  capabilityId: "experiment.metric.list",
+  description: "List experiment metrics in a project.",
+  flags: [{ name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id") })
+});
+
+// src/commands/te-experiment/metric/save.ts
+var aggregations = /* @__PURE__ */ new Set([
+  "total_count",
+  "user_count",
+  "active_days",
+  "sum",
+  "avg",
+  "max",
+  "distinct_count"
+]);
+var propertyAggregations = /* @__PURE__ */ new Set(["sum", "avg", "max", "distinct_count"]);
+var metricDefinitionFields = /* @__PURE__ */ new Set([
+  "type",
+  "event",
+  "aggregation",
+  "property",
+  "filters"
+]);
+function validateMetricFilters(rawFilters) {
+  if (rawFilters === void 0) return;
+  if (!rawFilters || typeof rawFilters !== "object" || Array.isArray(rawFilters)) {
+    throw new Error("Flag --req.metricDefinition.filters must be a JSON object");
+  }
+  const filters = rawFilters;
+  if (!["and", "or"].includes(String(filters.relation))) {
+    throw new Error("Flag --req.metricDefinition.filters.relation must be one of: and, or");
+  }
+  if (!Array.isArray(filters.items) || filters.items.length === 0) {
+    throw new Error("Flag --req.metricDefinition.filters.items must be a non-empty array");
+  }
+  filters.items.forEach((rawItem, index) => {
+    const path = `Flag --req.metricDefinition.filters.items[${index}]`;
+    if (!rawItem || typeof rawItem !== "object" || Array.isArray(rawItem)) {
+      throw new Error(`${path} must be a JSON object`);
+    }
+    const item = rawItem;
+    const field = item.field;
+    const validField = typeof field === "string" && field.trim() !== "" || Boolean(field && typeof field === "object" && !Array.isArray(field) && typeof field.name === "string" && String(field.name).trim() !== "");
+    if (!validField) throw new Error(`${path}.field is required`);
+    if (typeof item.operator !== "string" || item.operator.trim() === "") {
+      throw new Error(`${path}.operator is required and expresses the property comparison`);
+    }
+    if (!Array.isArray(item.values)) {
+      throw new Error(`${path}.values must be an array containing the comparison value(s)`);
+    }
+  });
+}
+function validateMetricSaveRequest(req) {
+  const rawDefinition = req.metricDefinition;
+  if (rawDefinition === void 0 && req.update === true) return;
+  if (!rawDefinition || typeof rawDefinition !== "object" || Array.isArray(rawDefinition)) {
+    throw new Error("Flag --req.metricDefinition must be a JSON object");
+  }
+  const definition = rawDefinition;
+  for (const field of Object.keys(definition)) {
+    if (!metricDefinitionFields.has(field)) {
+      throw new Error(`Flag --req.metricDefinition.${field} is not supported`);
+    }
+  }
+  if (definition.type !== "event") {
+    throw new Error("Flag --req.metricDefinition.type must be event");
+  }
+  if (typeof definition.event !== "string" || definition.event.trim() === "") {
+    throw new Error("Flag --req.metricDefinition.event is required");
+  }
+  if (typeof definition.aggregation !== "string" || !aggregations.has(definition.aggregation)) {
+    throw new Error(`Flag --req.metricDefinition.aggregation must be one of: ${[...aggregations].join(", ")}`);
+  }
+  if (propertyAggregations.has(definition.aggregation) && (typeof definition.property !== "string" || definition.property.trim() === "")) {
+    throw new Error(`Flag --req.metricDefinition.property is required for ${definition.aggregation}`);
+  }
+  validateMetricFilters(definition.filters);
+}
+var metricSave = createExperimentCapabilityCommand({
+  resource: "metric",
+  command: "save",
+  capabilityId: "experiment.metric.save",
+  description: "Create or update an experiment metric.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    {
+      name: "req",
+      type: "json",
+      required: true,
+      desc: "Native camelCase request. Property comparisons use metricDefinition.filters={relation,items:[{field,operator,values}]}. Never use metricConfig, calcType, or raw filts."
+    }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    validateMetricSaveRequest(readRequiredObject(ctx, "req"));
+  },
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredObject(ctx, "req") })
+});
+
+// src/commands/te-experiment/operation-log/query.ts
+var operationLogQuery = createExperimentCapabilityCommand({
+  resource: "operation-log",
+  command: "query",
+  capabilityId: "experiment.operation-log.query",
+  description: "Query full operation logs for one experiment, including remark and structured changes.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    exp_id: ctx.str("exp-id")
+  })
+});
+
+// src/commands/te-experiment/save/build-guide.ts
+var saveBuildGuide = createExperimentCapabilityCommand({
+  resource: "save",
+  command: "build-guide",
+  capabilityId: "experiment.save.build-guide",
+  description: "Build a read-only save guide for feature, traffic layer, experiment, or metric saves. WARNING: data.guide.example_args.req keys are recursively snake_cased for display; do not copy them into --req. Final save DTOs require camelCase (e.g. expName). Prefer capability inspect <final-save-id> input_schema.properties.req.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    {
+      name: "operation-mode",
+      type: "string",
+      required: true,
+      desc: "Save operation mode: save_feature, save_traffic_layer, save_experiment, or save_metric."
+    }
+  ],
+  risk: "read",
+  validate: (ctx) => {
+    const mode = ctx.str("operation-mode");
+    if (!["save_feature", "save_traffic_layer", "save_experiment", "save_metric"].includes(mode)) {
+      throw new Error("Flag --operation-mode must be one of: save_feature, save_traffic_layer, save_experiment, save_metric");
+    }
+  },
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    operation_mode: ctx.str("operation-mode")
+  })
+});
+
+// src/commands/te-experiment/save/validate.ts
+var saveValidate = createExperimentCapabilityCommand({
+  resource: "save",
+  command: "validate",
+  capabilityId: "experiment.save.validate",
+  description: "Dry-run validation for feature, traffic layer, experiment, or metric save requests. WARNING: valid=true is not a final-save schema pass; snake_case req keys (e.g. exp_name) can still fail on experiment \u2026 save. Always pass camelCase --req. Do not copy example_args.req key casing from this response.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    {
+      name: "operation-mode",
+      type: "string",
+      required: true,
+      desc: "Save operation mode: save_feature, save_traffic_layer, save_experiment, or save_metric."
+    },
+    {
+      name: "req",
+      type: "json",
+      required: true,
+      desc: "Candidate camelCase save request object (expName/metricId/\u2026). Never use snake_case DTO keys."
+    }
+  ],
+  risk: "read",
+  validate: (ctx) => {
+    const mode = ctx.str("operation-mode");
+    if (!["save_feature", "save_traffic_layer", "save_experiment", "save_metric"].includes(mode)) {
+      throw new Error("Flag --operation-mode must be one of: save_feature, save_traffic_layer, save_experiment, save_metric");
+    }
+    readRequiredObject(ctx, "req");
+  },
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    operation_mode: ctx.str("operation-mode"),
+    req: readRequiredObject(ctx, "req")
+  })
+});
+
+// src/commands/te-experiment/report/metric-trend.ts
+var reportMetricTrend = createExperimentCapabilityCommand({
+  resource: "report",
+  command: "metric-trend",
+  capabilityId: "experiment.report.metric-trend",
+  description: "Query an experiment metric trend report for a date range.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment ID." },
+    { name: "metric-id", type: "string", required: true, desc: "Metric ID." },
+    { name: "start-time", type: "string", required: true, desc: "Start date in yyyy-MM-dd format." },
+    { name: "end-time", type: "string", required: true, desc: "End date in yyyy-MM-dd format." },
+    {
+      name: "request-id",
+      type: "string",
+      required: false,
+      desc: "Optional caller-supplied cli_<32 lowercase hex> lifecycle ID. ae-cli generates and prints one before dispatch when omitted."
+    },
+    { name: "force-refresh", type: "boolean", required: false, desc: "Force refresh report data." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => {
+    const input = {
+      project_id: ctx.num("project-id"),
+      exp_id: ctx.str("exp-id"),
+      metric_id: ctx.str("metric-id"),
+      start_time: ctx.str("start-time"),
+      end_time: ctx.str("end-time")
+    };
+    addOptionalString(input, "request_id", ctx.str("request-id"));
+    addOptionalBoolean(input, ctx, "force-refresh", "force_refresh");
+    return input;
+  }
+});
+
+// src/commands/te-experiment/report/sample-size.ts
+var reportSampleSize = createExperimentCapabilityCommand({
+  resource: "report",
+  command: "sample-size",
+  capabilityId: "experiment.report.sample-size",
+  description: "Query an experiment sample-size report for a date range.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment ID." },
+    { name: "start-time", type: "string", required: true, desc: "Start date in yyyy-MM-dd format." },
+    { name: "end-time", type: "string", required: true, desc: "End date in yyyy-MM-dd format." },
+    {
+      name: "request-id",
+      type: "string",
+      required: false,
+      desc: "Optional caller-supplied cli_<32 lowercase hex> lifecycle ID. ae-cli generates and prints one before dispatch when omitted."
+    },
+    { name: "force-refresh", type: "boolean", required: false, desc: "Force refresh report data." },
+    { name: "by-hour", type: "boolean", required: false, desc: "Break results down by hour." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => {
+    const input = {
+      project_id: ctx.num("project-id"),
+      exp_id: ctx.str("exp-id"),
+      start_time: ctx.str("start-time"),
+      end_time: ctx.str("end-time")
+    };
+    addOptionalString(input, "request_id", ctx.str("request-id"));
+    addOptionalBoolean(input, ctx, "force-refresh", "force_refresh");
+    addOptionalBoolean(input, ctx, "by-hour", "by_hour");
+    return input;
+  }
+});
+
+// src/commands/te-experiment/report/summary.ts
+var reportSummary = createExperimentCapabilityCommand({
+  resource: "report",
+  command: "summary",
+  capabilityId: "experiment.report.summary",
+  description: "Query an experiment report summary.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment ID." },
+    { name: "force-refresh", type: "boolean", required: false, desc: "Force refresh report data." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => {
+    const input = {
+      project_id: ctx.num("project-id"),
+      exp_id: ctx.str("exp-id")
+    };
+    addOptionalBoolean(input, ctx, "force-refresh", "force_refresh");
+    return input;
+  }
+});
+
+// src/commands/te-experiment/traffic-layer/batch-delete.ts
+var trafficLayerBatchDelete = createExperimentCapabilityCommand({
+  resource: "traffic-layer",
+  command: "batch-delete",
+  capabilityId: "experiment.traffic-layer.batch-delete",
+  description: "Batch delete traffic layers.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "layer-ids", type: "json", required: true, desc: "Traffic layer IDs as a JSON string array." }
+  ],
+  risk: "high-risk-write",
+  validate: (ctx) => {
+    readRequiredStringArray(ctx, "layer-ids");
+  },
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    layer_ids: readRequiredStringArray(ctx, "layer-ids")
+  })
+});
+
+// src/commands/te-experiment/traffic-layer/get.ts
+var trafficLayerGet = createExperimentCapabilityCommand({
+  resource: "traffic-layer",
+  command: "get",
+  capabilityId: "experiment.traffic-layer.get",
+  description: "Get one traffic layer by ID.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "layer-id", type: "string", required: true, desc: "Traffic layer ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), layer_id: ctx.str("layer-id") })
+});
+
+// src/commands/te-experiment/traffic-layer/list.ts
+var trafficLayerList = createExperimentCapabilityCommand({
+  resource: "traffic-layer",
+  command: "list",
+  capabilityId: "experiment.traffic-layer.list",
+  description: "List traffic layers in a project.",
+  flags: [{ name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id") })
+});
+
+// src/commands/te-experiment/traffic-layer/save.ts
+var trafficLayerSave = createExperimentCapabilityCommand({
+  resource: "traffic-layer",
+  command: "save",
+  capabilityId: "experiment.traffic-layer.save",
+  description: "Create or update a traffic layer.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "req", type: "json", required: true, desc: "Native camelCase traffic layer save request object." }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    readRequiredObject(ctx, "req");
+  },
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredObject(ctx, "req") })
+});
+
+// src/commands/te-experiment/index.ts
+registerCapabilityGatewayRoute("experiment", { gatewayDomain: "engage" });
+var commands = [
+  experimentSave,
+  experimentList,
+  experimentListArchived,
+  experimentGet,
+  experimentReadyCheck,
+  experimentConflictCheck,
+  experimentManage,
+  experimentUpdateGroup,
+  experimentUpdateMetrics,
+  experimentBatchDelete,
+  operationLogQuery,
+  saveBuildGuide,
+  saveValidate,
+  trafficLayerSave,
+  trafficLayerGet,
+  trafficLayerList,
+  trafficLayerBatchDelete,
+  reportSummary,
+  reportSampleSize,
+  reportMetricTrend,
+  metricSave,
+  metricGet,
+  metricList,
+  metricDelete,
+  featureSave,
+  featureUpdateStatus,
+  featureGet,
+  featureList,
+  featureVersionList,
+  featureOperationLogQuery,
+  featureBatchDelete,
+  featureWhitelistList,
+  featureWhitelistSave,
+  featureWhitelistUpdateStatus,
+  featureWhitelistBatchDelete,
+  bucketList
+];
+var te_experiment_default = commands;
+export {
+  bucketList,
+  te_experiment_default as default,
+  experimentBatchDelete,
+  experimentConflictCheck,
+  experimentGet,
+  experimentList,
+  experimentListArchived,
+  experimentManage,
+  experimentReadyCheck,
+  experimentSave,
+  experimentUpdateGroup,
+  experimentUpdateMetrics,
+  featureBatchDelete,
+  featureGet,
+  featureList,
+  featureOperationLogQuery,
+  featureSave,
+  featureUpdateStatus,
+  featureVersionList,
+  featureWhitelistBatchDelete,
+  featureWhitelistList,
+  featureWhitelistSave,
+  featureWhitelistUpdateStatus,
+  metricDelete,
+  metricGet,
+  metricList,
+  metricSave,
+  operationLogQuery,
+  reportMetricTrend,
+  reportSampleSize,
+  reportSummary,
+  saveBuildGuide,
+  saveValidate,
+  trafficLayerBatchDelete,
+  trafficLayerGet,
+  trafficLayerList,
+  trafficLayerSave
+};