@thinkingai/ae-cli 6.1.11 → 6.1.12

package/dist/{te-engage-F7V55KVW.js → te-engage-QWM4GFS7.js}

@@ -209,6 +209,362 @@ var flowModifyBaseInfo = createEngageFlowCapabilityCommand({
   })
 });
 
+// src/commands/te-engage/semantic-qp-validation.ts
+var OPERATORS = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "exists",
+  "not_exists",
+  "between",
+  "contains",
+  "not_contains",
+  "is_true",
+  "is_false",
+  "regex",
+  "not_regex",
+  "relative_current_time",
+  "relative_event_time",
+  "array_contains",
+  "in_cluster",
+  "not_in_cluster"
+]);
+var AUDIENCE_AGGREGATIONS = /* @__PURE__ */ new Set([
+  "count",
+  "active_days",
+  "sum",
+  "avg",
+  "max",
+  "min",
+  "distinct_count"
+]);
+var METRIC_AGGREGATIONS = /* @__PURE__ */ new Set([
+  "total_count",
+  "user_count",
+  "per_user_count",
+  "sum",
+  "avg",
+  "avg_per_user",
+  "max",
+  "min",
+  "distinct_count",
+  "median",
+  "percentile",
+  "variance",
+  "stddev"
+]);
+function validateSemanticAudienceDefinition(value, path) {
+  const definition = object(value, path);
+  rejectUnknown(definition, ["type", "conditions", "include_filter", "exclude_filter"], path);
+  exactString(definition.type, "condition", `${path}.type`);
+  validateGroup(definition.conditions, `${path}.conditions`);
+  optional(definition.include_filter, (item) => validateGroup(item, `${path}.include_filter`));
+  optional(definition.exclude_filter, (item) => validateGroup(item, `${path}.exclude_filter`));
+}
+function validateSemanticEventDefinition(value, path) {
+  const event = object(value, path);
+  rejectUnknown(event, [
+    "type",
+    "event",
+    "operator",
+    "value",
+    "aggregation",
+    "property",
+    "time_range",
+    "filters"
+  ], path);
+  exactString(event.type, "event", `${path}.type`);
+  nonBlankString(event.event, `${path}.event`);
+  optionalEnum(event.operator, OPERATORS, `${path}.operator`);
+  optionalNumber(event.value, `${path}.value`);
+  optionalEnum(event.aggregation, AUDIENCE_AGGREGATIONS, `${path}.aggregation`);
+  optionalString(event.property, `${path}.property`);
+  optional(event.time_range, (item) => validateTimeRange(item, `${path}.time_range`));
+  optional(event.filters, (item) => validateFilterGroup(item, `${path}.filters`));
+}
+function validateSemanticMetricDefinition(value, path) {
+  const metric = object(value, path);
+  if (metric.type === "event") {
+    validateMetricEvent(metric, path, false);
+    return;
+  }
+  if (metric.type === "formula") {
+    rejectUnknown(metric, ["type", "expression", "dependencies", "format"], path);
+    nonBlankString(metric.expression, `${path}.expression`);
+    optionalString(metric.format, `${path}.format`);
+    array(metric.dependencies, `${path}.dependencies`, 1).forEach((dependency, index) => validateMetricEvent(
+      object(dependency, `${path}.dependencies[${index}]`),
+      `${path}.dependencies[${index}]`,
+      true
+    ));
+    return;
+  }
+  invalid(`${path}.type must be event or formula.`);
+}
+function validateEmbeddedSemanticDefinitions(value, path) {
+  walk(value, path);
+}
+function walk(value, path) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => walk(item, `${path}[${index}]`));
+    return;
+  }
+  if (!isObject(value)) return;
+  for (const [key, item] of Object.entries(value)) {
+    const itemPath = `${path}.${key}`;
+    if (item === void 0 || item === null) continue;
+    if (["definitionRequest", "targetDefinitionRequest", "topicDefinitionRequest"].includes(key)) {
+      validateSemanticAudienceDefinition(item, itemPath);
+    } else if (key === "eventDefinition") {
+      validateSemanticEventDefinition(item, itemPath);
+    } else if (key === "triggerDefinition") {
+      validateTriggerDefinition(item, itemPath);
+    } else if (key === "config" && typeof item === "string") {
+      walkJsonString(item, itemPath);
+    } else {
+      walk(item, itemPath);
+    }
+  }
+}
+function validateTriggerDefinition(value, path) {
+  const definition = object(value, path);
+  rejectUnknown(definition, ["rules"], path);
+  array(definition.rules, `${path}.rules`, 1).forEach((ruleValue, ruleIndex) => {
+    const rulePath = `${path}.rules[${ruleIndex}]`;
+    const rule = object(ruleValue, rulePath);
+    array(rule.events, `${rulePath}.events`, 1).forEach((event, eventIndex) => {
+      const eventPath = `${rulePath}.events[${eventIndex}]`;
+      const candidate = object(event, eventPath);
+      if ("eventDefinition" in candidate) {
+        validateSemanticEventDefinition(candidate.eventDefinition, `${eventPath}.eventDefinition`);
+      } else {
+        validateSemanticEventDefinition(candidate, eventPath);
+      }
+    });
+    optional(rule.blackList, (items) => array(items, `${rulePath}.blackList`).forEach((event, index) => validateSemanticEventDefinition(
+      event,
+      `${rulePath}.blackList[${index}]`
+    )));
+  });
+}
+function validateGroup(value, path) {
+  const group = object(value, path);
+  rejectUnknown(group, ["relation", "items"], path);
+  enumValue(group.relation, /* @__PURE__ */ new Set(["and", "or"]), `${path}.relation`);
+  array(group.items, `${path}.items`, 1).forEach((item, index) => validateCondition(item, `${path}.items[${index}]`));
+}
+function validateCondition(value, path) {
+  const condition = object(value, path);
+  switch (condition.type) {
+    case "event":
+      validateSemanticEventDefinition(condition, path);
+      required(condition.time_range, `${path}.time_range`);
+      return;
+    case "user":
+    case "tag":
+    case "cluster":
+      validatePropertyCondition(condition, path);
+      return;
+    case "compound":
+      rejectUnknown(condition, ["type", "group"], path);
+      validateGroup(condition.group, `${path}.group`);
+      return;
+    case "behavior_sequence":
+      validateBehaviorSequence(condition, path);
+      return;
+    default:
+      invalid(`${path}.type is unsupported.`);
+  }
+}
+function validatePropertyCondition(condition, path) {
+  const extended = condition.type === "tag" || condition.type === "cluster";
+  rejectUnknown(condition, [
+    "type",
+    "field",
+    "operator",
+    "values",
+    "time_relative",
+    "time_unit",
+    ...extended ? ["cluster_date_policy", "specified_cluster_date"] : []
+  ], path);
+  validateField(condition.field, `${path}.field`);
+  if (condition.type === "user") enumValue(condition.operator, OPERATORS, `${path}.operator`);
+  else optionalEnum(condition.operator, OPERATORS, `${path}.operator`);
+  optional(condition.values, (item) => array(item, `${path}.values`));
+  optionalString(condition.time_relative, `${path}.time_relative`);
+  optionalString(condition.time_unit, `${path}.time_unit`);
+  optionalString(condition.cluster_date_policy, `${path}.cluster_date_policy`);
+  optionalString(condition.specified_cluster_date, `${path}.specified_cluster_date`);
+}
+function validateBehaviorSequence(condition, path) {
+  rejectUnknown(condition, ["type", "completed", "steps", "time_range", "window"], path);
+  if (typeof condition.completed !== "boolean") invalid(`${path}.completed must be a boolean.`);
+  array(condition.steps, `${path}.steps`, 1).forEach((stepValue, index) => {
+    const stepPath = `${path}.steps[${index}]`;
+    const step = object(stepValue, stepPath);
+    rejectUnknown(step, ["event", "completed", "filters", "relative_to_first", "window"], stepPath);
+    nonBlankString(step.event, `${stepPath}.event`);
+    optionalBoolean(step.completed, `${stepPath}.completed`);
+    optionalBoolean(step.relative_to_first, `${stepPath}.relative_to_first`);
+    if (index === 1 && step.relative_to_first === true) {
+      invalid(`${stepPath}.relative_to_first must be false or omitted for the second step.`);
+    }
+    optional(step.filters, (item) => validateFilterGroup(item, `${stepPath}.filters`));
+    optional(step.window, (item) => validateWindow(item, `${stepPath}.window`));
+  });
+  required(condition.time_range, `${path}.time_range`);
+  validateTimeRange(condition.time_range, `${path}.time_range`);
+  optional(condition.window, (item) => validateWindow(item, `${path}.window`));
+}
+function validateFilterGroup(value, path) {
+  const group = object(value, path);
+  rejectUnknown(group, ["relation", "items"], path);
+  optionalEnum(group.relation, /* @__PURE__ */ new Set(["and", "or"]), `${path}.relation`);
+  array(group.items, `${path}.items`, 1).forEach((filterValue, index) => {
+    const filterPath = `${path}.items[${index}]`;
+    const filter = object(filterValue, filterPath);
+    rejectUnknown(filter, ["field", "operator", "values"], filterPath);
+    validateField(filter.field, `${filterPath}.field`);
+    enumValue(filter.operator, OPERATORS, `${filterPath}.operator`);
+    optional(filter.values, (item) => array(item, `${filterPath}.values`));
+  });
+}
+function validateField(value, path) {
+  if (typeof value === "string") {
+    nonBlankString(value, path);
+    return;
+  }
+  const field = object(value, path);
+  rejectUnknown(field, ["name", "type"], path);
+  nonBlankString(field.name, `${path}.name`);
+  optionalEnum(field.type, /* @__PURE__ */ new Set([
+    "event_property",
+    "user_property",
+    "tag",
+    "cluster"
+  ]), `${path}.type`);
+}
+function validateTimeRange(value, path) {
+  const range = object(value, path);
+  rejectUnknown(range, ["mode", "unit", "value", "start_time", "end_time"], path);
+  if (range.mode === "custom") {
+    nonBlankString(range.start_time, `${path}.start_time`);
+    nonBlankString(range.end_time, `${path}.end_time`);
+    return;
+  }
+  enumValue(range.mode, /* @__PURE__ */ new Set(["recent", "previous"]), `${path}.mode`);
+  optional(range.unit, (unit) => exactString(unit, "day", `${path}.unit`));
+  positiveInteger(range.value, `${path}.value`);
+}
+function validateWindow(value, path) {
+  const window = object(value, path);
+  rejectUnknown(window, ["value", "unit"], path);
+  positiveInteger(window.value, `${path}.value`);
+  nonBlankString(window.unit, `${path}.unit`);
+}
+function validateMetricEvent(metric, path, dependency) {
+  rejectUnknown(metric, [
+    "type",
+    ...dependency ? ["key"] : [],
+    "event",
+    "aggregation",
+    "property",
+    "percentile",
+    "filters",
+    "display_name"
+  ], path);
+  exactString(metric.type, "event", `${path}.type`);
+  if (dependency) nonBlankString(metric.key, `${path}.key`);
+  nonBlankString(metric.event, `${path}.event`);
+  enumValue(metric.aggregation, METRIC_AGGREGATIONS, `${path}.aggregation`);
+  if (!["total_count", "user_count", "per_user_count"].includes(String(metric.aggregation))) {
+    nonBlankString(metric.property, `${path}.property`);
+  }
+  optionalString(metric.property, `${path}.property`);
+  if (metric.aggregation === "percentile") {
+    optionalNumber(metric.percentile, `${path}.percentile`);
+    if (typeof metric.percentile !== "number" || metric.percentile <= 0 || metric.percentile > 100) {
+      invalid(`${path}.percentile must be greater than 0 and at most 100.`);
+    }
+  } else if (metric.percentile !== void 0 && metric.percentile !== null) {
+    invalid(`${path}.percentile is only valid for percentile aggregation.`);
+  }
+  optionalString(metric.display_name, `${path}.display_name`);
+  optional(metric.filters, (item) => validateFilterGroup(item, `${path}.filters`));
+}
+function walkJsonString(value, path) {
+  try {
+    walk(JSON.parse(value), path);
+  } catch (error) {
+    if (error instanceof SyntaxError) invalid(`${path} must contain valid JSON.`);
+    throw error;
+  }
+}
+function object(value, path) {
+  if (!isObject(value)) invalid(`${path} must be a JSON object.`);
+  return value;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function array(value, path, minLength = 0) {
+  if (!Array.isArray(value) || value.length < minLength) {
+    invalid(`${path} must be an array with at least ${minLength} item(s).`);
+  }
+  return value;
+}
+function rejectUnknown(value, allowed, path) {
+  const supported = new Set(allowed);
+  const unknown = Object.keys(value).find((key) => !supported.has(key));
+  if (unknown) invalid(`Unsupported field ${path}.${unknown}.`);
+}
+function optional(value, validate) {
+  if (value !== void 0 && value !== null) validate(value);
+}
+function required(value, path) {
+  if (value === void 0 || value === null) invalid(`${path} is required.`);
+}
+function nonBlankString(value, path) {
+  if (typeof value !== "string" || value.trim() === "") {
+    invalid(`${path} must be a non-blank string.`);
+  }
+}
+function optionalString(value, path) {
+  optional(value, (item) => nonBlankString(item, path));
+}
+function exactString(value, expected, path) {
+  if (value !== expected) invalid(`${path} must be ${expected}.`);
+}
+function enumValue(value, allowed, path) {
+  if (typeof value !== "string" || !allowed.has(value)) {
+    invalid(`${path} must be one of: ${[...allowed].join(", ")}.`);
+  }
+}
+function optionalEnum(value, allowed, path) {
+  optional(value, (item) => enumValue(item, allowed, path));
+}
+function optionalNumber(value, path) {
+  optional(value, (item) => {
+    if (typeof item !== "number" || !Number.isFinite(item)) invalid(`${path} must be a number.`);
+  });
+}
+function positiveInteger(value, path) {
+  if (!Number.isInteger(value) || value < 1) {
+    invalid(`${path} must be a positive integer.`);
+  }
+}
+function optionalBoolean(value, path) {
+  optional(value, (item) => {
+    if (typeof item !== "boolean") invalid(`${path} must be a boolean.`);
+  });
+}
+function invalid(message) {
+  throw new CliValidationError(message);
+}
+
 // src/commands/te-engage/engage-flow/flow/save.ts
 var allowedOperations = ["build", "preview", "commit"];
 function readRequest(ctx) {
@@ -223,6 +579,7 @@ function readRequest(ctx) {
   if ("sourceFlowUuid" in req) {
     throw new Error("Flag --req.sourceFlowUuid is unsupported; get the source flow and build nodes/edges instead");
   }
+  validateEmbeddedSemanticDefinitions(req, "--req");
   return req;
 }
 var flowSave = createEngageFlowCapabilityCommand({
@@ -1042,6 +1399,12 @@ var presetEventUpdate = createEngageSettingCapabilityCommand({
     { name: "recharge-event-definition", type: "json", required: false, desc: "Semantic recharge event definition." }
   ],
   risk: "write",
+  validate: (ctx) => {
+    for (const name of ["add-event-definition", "active-event-definition", "recharge-event-definition"]) {
+      const definition = ctx.json(name);
+      if (definition !== void 0) validateSemanticEventDefinition(definition, `--${name}`);
+    }
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
     add_event_definition: ctx.json("add-event-definition") || void 0,
@@ -1085,23 +1448,7 @@ var commonMetricGet = createEngageSettingCapabilityCommand({
 // src/commands/te-engage/engage-setting/common-metric/metric-qp-validation.ts
 var VALID_WINDOW_TIME_UNITS = /* @__PURE__ */ new Set(["minute", "hour", "day"]);
 function validateMetricDefinitionFlag(definition) {
-  if (definition === null || typeof definition !== "object" || Array.isArray(definition)) {
-    printError(
-      "validation",
-      "--metric-definition must be a JSON object.",
-      "Pass a semantic event or formula metric definition."
-    );
-    process.exit(1);
-  }
-  const type = definition.type;
-  if (type !== "event" && type !== "formula") {
-    printError(
-      "validation",
-      "--metric-definition.type must be event or formula.",
-      "Do not pass legacy type=0/1 metric_qp."
-    );
-    process.exit(1);
-  }
+  validateSemanticMetricDefinition(definition, "--metric-definition");
 }
 function validateMetricWindowTimeUnitFlag(unit) {
   if (VALID_WINDOW_TIME_UNITS.has(unit)) {
@@ -1587,6 +1934,16 @@ var presetMetricSet = createEngageSceneCapabilityCommand({
     { name: "attend-event-definition", type: "json", required: false, desc: "Semantic attend event definition." }
   ],
   risk: "write",
+  validate: (ctx) => {
+    for (const name of [
+      "impression-event-definition",
+      "click-event-definition",
+      "attend-event-definition"
+    ]) {
+      const definition = ctx.json(name);
+      if (definition !== void 0) validateSemanticEventDefinition(definition, `--${name}`);
+    }
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
     config_id: ctx.str("config-id"),
@@ -1865,9 +2222,13 @@ var strategyCreate = createEngageSceneCapabilityCommand({
     }
   ],
   risk: "write",
+  validate: (ctx) => {
+    const payload = readRequiredJsonObject(ctx, "payload");
+    validateEmbeddedSemanticDefinitions(payload, "--payload");
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
-    payload: ctx.json("payload")
+    payload: readRequiredJsonObject(ctx, "payload")
   })
 });
 
@@ -1964,9 +2325,13 @@ var strategyUpdate = createEngageSceneCapabilityCommand({
     }
   ],
   risk: "write",
+  validate: (ctx) => {
+    const payload = readRequiredJsonObject(ctx, "payload");
+    validateEmbeddedSemanticDefinitions(payload, "--payload");
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
-    payload: ctx.json("payload")
+    payload: readRequiredJsonObject(ctx, "payload")
   })
 });
 
@@ -2022,7 +2387,10 @@ var strategyPredict = createEngageSceneCapabilityCommand({
   ],
   risk: "read",
   validate: (ctx) => {
-    readRequiredJsonObject(ctx, "definition-request");
+    validateSemanticAudienceDefinition(
+      readRequiredJsonObject(ctx, "definition-request"),
+      "--definition-request"
+    );
   },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
@@ -2513,6 +2881,7 @@ var TOPIC_TASK_EXCLUSION_FIELDS = /* @__PURE__ */ new Set([
 ]);
 function validateStandaloneActivityPayload(value) {
   const payload = requireObject(value);
+  validateEmbeddedSemanticDefinitions(payload, "payload");
   validateTriggerType(payload.triggerType, "triggerType");
   validateScheduleFields(payload);
   validateExperiment(payload.expConfig, "expConfig");
@@ -2536,6 +2905,7 @@ function validateStandaloneActivityPayload(value) {
 }
 function validateActivityTopicPayload(value) {
   const payload = requireObject(value);
+  validateEmbeddedSemanticDefinitions(payload, "payload");
   validateTriggerType(payload.triggerType, "triggerType");
   validateScheduleFields(payload);
   validateExperiment(payload.expConfig, "expConfig");
@@ -2610,7 +2980,7 @@ function validateScheduleFields(payload) {
 }
 function validateExperiment(value, field) {
   if (value === void 0 || value === null) return;
-  if (!isObject(value)) {
+  if (!isObject2(value)) {
     fail(
       `${field} must be omitted or set to {"enableExp":false}.`,
       "ACTIVITY_EXPERIMENT_UNSUPPORTED",
@@ -2641,7 +3011,7 @@ function validateSingleContentGroup(value, field) {
   }
 }
 function requireObject(value, field = "payload") {
-  if (!isObject(value)) {
+  if (!isObject2(value)) {
     fail(
       `${field} must be a JSON object.`,
       "ACTIVITY_PAYLOAD_INVALID",
@@ -2653,7 +3023,7 @@ function requireObject(value, field = "payload") {
 }
 function containsAnyKey(value, keys) {
   if (Array.isArray(value)) return value.some((item) => containsAnyKey(item, keys));
-  if (!isObject(value)) return false;
+  if (!isObject2(value)) return false;
   return Object.entries(value).some(
     ([key, item]) => keys.has(key) && hasValue(item) || containsAnyKey(item, keys)
   );
@@ -2662,10 +3032,10 @@ function hasValue(value) {
   if (value === void 0 || value === null) return false;
   if (typeof value === "string") return value.trim().length > 0;
   if (Array.isArray(value)) return value.length > 0;
-  if (isObject(value)) return Object.keys(value).length > 0;
+  if (isObject2(value)) return Object.keys(value).length > 0;
   return true;
 }
-function isObject(value) {
+function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function fail(message, code, field, hint) {
@@ -3522,7 +3892,7 @@ var taskSave = createEngageTaskCapabilityCommand({
   ],
   risk: "write",
   validate: (ctx) => {
-    readRequiredJsonObject(ctx, "req");
+    validateEmbeddedSemanticDefinitions(readRequiredJsonObject(ctx, "req"), "--req");
   },
   buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredJsonObject(ctx, "req") })
 });

package/dist/{te-experiment-UPDMHCAJ.js → te-experiment-2T2HEZML.js}

@@ -37,6 +37,9 @@ function readRequiredStringArray(ctx, name) {
 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({
@@ -481,7 +484,7 @@ 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.",
+  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." },
     {
@@ -509,7 +512,7 @@ var saveValidate = createExperimentCapabilityCommand({
   resource: "save",
   command: "validate",
   capabilityId: "experiment.save.validate",
-  description: "Dry-run validation for feature, traffic layer, experiment, or metric save requests.",
+  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." },
     {
@@ -518,7 +521,12 @@ var saveValidate = createExperimentCapabilityCommand({
       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." }
+    {
+      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) => {
@@ -535,6 +543,98 @@ var saveValidate = createExperimentCapabilityCommand({
   })
 });
 
+// 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",
@@ -616,6 +716,9 @@ var commands = [
   trafficLayerGet,
   trafficLayerList,
   trafficLayerBatchDelete,
+  reportSummary,
+  reportSampleSize,
+  reportMetricTrend,
   metricSave,
   metricGet,
   metricList,
@@ -654,6 +757,9 @@ export {
   metricList,
   metricSave,
   operationLogQuery,
+  reportMetricTrend,
+  reportSampleSize,
+  reportSummary,
   saveBuildGuide,
   saveValidate,
   trafficLayerBatchDelete,