@koda-sl/baker-cli 0.354.0-dev.e6a354971 → 0.354.0

package/dist/cli.js

@@ -68,7 +68,7 @@ import {
   validateCanvasDeep,
   withoutCastName,
   ytDlpBlockSignal
-} from "./chunk-B7MLH3K6.js";
+} from "./chunk-4HRJQGVW.js";
 import {
   csvOrJson,
   daysAgoIso,
@@ -10564,6 +10564,102 @@ function hintsFor(scope, days) {
   return hints2;
 }
 
+// src/commands/ads/google/list-fields.ts
+var LIST_FIELDS = /* @__PURE__ */ new Set([
+  "ad.final_mobile_urls",
+  "ad.final_urls",
+  "ad_group.excluded_parent_asset_field_types",
+  "ad_group.excluded_parent_asset_set_types",
+  "ad_group.labels",
+  "ad_group.primary_status_reasons",
+  "ad_group_ad.ad.final_mobile_urls",
+  "ad_group_ad.ad.final_urls",
+  "ad_group_ad.labels",
+  "ad_group_ad.primary_status_reasons",
+  "ad_group_asset.primary_status_reasons",
+  "ad_group_criterion.disapproval_reasons",
+  "ad_group_criterion.final_mobile_urls",
+  "ad_group_criterion.final_urls",
+  "ad_group_criterion.labels",
+  "ad_group_criterion.primary_status_reasons",
+  "ad_group_criterion.topic.path",
+  "ad_group_criterion.webpage.sample.sample_urls",
+  "asset.dynamic_custom_asset.contextual_keywords",
+  "asset.dynamic_custom_asset.similar_ids",
+  "asset.dynamic_education_asset.contextual_keywords",
+  "asset.dynamic_education_asset.similar_program_ids",
+  "asset.dynamic_flights_asset.similar_destination_ids",
+  "asset.dynamic_hotels_and_rentals_asset.contextual_keywords",
+  "asset.dynamic_hotels_and_rentals_asset.similar_property_ids",
+  "asset.dynamic_jobs_asset.contextual_keywords",
+  "asset.dynamic_jobs_asset.similar_job_ids",
+  "asset.dynamic_local_asset.contextual_keywords",
+  "asset.dynamic_local_asset.similar_deal_ids",
+  "asset.dynamic_real_estate_asset.contextual_keywords",
+  "asset.dynamic_real_estate_asset.similar_listing_ids",
+  "asset.dynamic_travel_asset.contextual_keywords",
+  "asset.dynamic_travel_asset.similar_destination_ids",
+  "asset.final_mobile_urls",
+  "asset.final_urls",
+  "asset.page_feed_asset.labels",
+  "asset.structured_snippet_asset.values",
+  "asset_group.final_mobile_urls",
+  "asset_group.final_urls",
+  "asset_group.primary_status_reasons",
+  "asset_group_asset.primary_status_reasons",
+  "asset_group_signal.disapproval_reasons",
+  "asset_set.business_profile_location_group.dynamic_business_profile_location_group_filter.label_filters",
+  "asset_set.business_profile_location_group.dynamic_business_profile_location_group_filter.listing_id_filters",
+  "asset_set.location_set.business_profile_location_set.label_filters",
+  "asset_set.location_set.business_profile_location_set.listing_id_filters",
+  "bidding_data_exclusion.advertising_channel_types",
+  "bidding_data_exclusion.campaigns",
+  "bidding_data_exclusion.devices",
+  "bidding_seasonality_adjustment.advertising_channel_types",
+  "bidding_seasonality_adjustment.campaigns",
+  "bidding_seasonality_adjustment.devices",
+  "campaign.excluded_parent_asset_field_types",
+  "campaign.excluded_parent_asset_set_types",
+  "campaign.feed_types",
+  "campaign.labels",
+  "campaign.optimization_goal_setting.optimization_goal_types",
+  "campaign.primary_status_reasons",
+  "campaign.selective_optimization.conversion_actions",
+  "campaign.shopping_setting.advertising_partner_ids",
+  "campaign.text_guidelines.term_exclusions",
+  "campaign_asset.primary_status_reasons",
+  "campaign_criterion.location_group.geo_target_constants",
+  "campaign_criterion.topic.path",
+  "campaign_criterion.webpage.sample.sample_urls",
+  "conversion_value_rule.audience_condition.user_interests",
+  "conversion_value_rule.audience_condition.user_lists",
+  "conversion_value_rule.device_condition.device_types",
+  "conversion_value_rule.geo_location_condition.excluded_geo_target_constants",
+  "conversion_value_rule.geo_location_condition.geo_target_constants",
+  "conversion_value_rule_set.conversion_value_rules",
+  "conversion_value_rule_set.dimensions",
+  "custom_conversion_goal.conversion_actions",
+  "customer.pay_per_conversion_eligibility_failure_reasons",
+  "customer_asset.primary_status_reasons",
+  "customer_client.applied_labels",
+  "experiment_arm.campaigns",
+  "experiment_arm.in_design_campaigns",
+  "keyword_plan_campaign.language_constants",
+  "local_services_employee.category_ids",
+  "local_services_employee.languages_spoken",
+  "metrics.interaction_event_types",
+  "recommendation.campaigns",
+  "shared_criterion.webpage.sample.sample_urls",
+  "shopping_product.target_countries",
+  "topic_constant.path",
+  "user_list.lookalike_user_list.country_codes",
+  "user_list.lookalike_user_list.seed_user_list_ids"
+]);
+var LIST_FIELD_OPERATORS = "CONTAINS ALL, CONTAINS ANY, CONTAINS NONE";
+function listFieldGuidance(field) {
+  return `${field} is a list field: it takes only ${LIST_FIELD_OPERATORS} \u2014 no comparison (=, !=, IN), pattern match or null test. To find rows that have it, drop that condition, keep ${field} in SELECT and filter the rows (rows without it omit the key); to match values, use ${field} CONTAINS ANY ('value')`;
+}
+
 // src/commands/ads/google/correction-table.ts
 function buildCommand(query, ctx) {
   return `baker ads google query "${query}" --customer-id ${ctx.customerId}`;
@@ -10591,6 +10687,27 @@ var CORRECTION_RULES = [
       };
     }
   },
+  // 0b. OPERATOR_FIELD_MISMATCH — the field refuses this operator, and Google names the
+  // ones it takes. Kept ahead of the field-specific rules for the same reason as rule 0.
+  // A repeated field (final_urls, labels, …) takes only CONTAINS ALL/ANY/NONE, so it has
+  // no null test at all: read it unfiltered and filter the rows instead.
+  {
+    matchApiError: /OPERATOR_FIELD_MISMATCH|is not a valid operator to use with/i,
+    fix: (ctx) => {
+      const message = ctx.apiErrorMessage ?? "";
+      const field = message.match(/valid operator to use with '([\w.]+)'/i)?.[1] ?? "this field";
+      const operator = message.match(/([A-Z=!<>][A-Z_ =!<>]*?) is not a valid operator/)?.[1]?.trim();
+      const valid = message.match(/Valid operators: (.+?)\.?(?:"|$)/i)?.[1]?.trim();
+      const refused = operator ? `${operator} cannot be used on ${field}` : `${field} does not take that operator`;
+      const allowed = valid ? `; its valid operators are ${valid}` : "";
+      const repeated = valid?.split(",").every((op) => /^CONTAINS (ALL|ANY|NONE)$/i.test(op.trim())) ?? false;
+      const guidance = repeated ? `. ${listFieldGuidance(field)}` : ". Rewrite that condition with one of them, or drop it and filter the rows";
+      return {
+        action: "change_operator",
+        explanation: `${refused}${allowed}${guidance}`
+      };
+    }
+  },
   // 1. bare keyword.text → ad_group_criterion.keyword.text (leaves <resource>.keyword.text untouched)
   {
     matchQuery: /(?<![\w.])keyword\.text\b/,
@@ -10633,10 +10750,11 @@ var CORRECTION_RULES = [
       };
     }
   },
-  // 4. CONTAINS → LIKE
+  // 4. CONTAINS → LIKE. Keyed on the query alone: Google's error envelope ("Request contains an
+  // invalid argument … Valid operators: CONTAINS ANY") matches any loose error pattern, and this
+  // advice only makes sense when the query actually wrote CONTAINS(…).
   {
     matchQuery: /CONTAINS\s*\(/i,
-    matchApiError: /CONTAINS.*not.*supported|invalid.*operator.*CONTAINS/i,
     fix: (ctx) => {
       const match = ctx.originalQuery.match(/CONTAINS\s*\(\s*([^,]+),\s*'([^']+)'\s*\)/i);
       if (match) {
@@ -13082,6 +13200,73 @@ function rejectOversizedLimit(query, customerId) {
     }
   };
 }
+var WHERE_OPERATOR = /(?<![\w.])([a-z_]+(?:\.[a-z_]+)+)\s*(CONTAINS\s+(?:ALL|ANY|NONE)|IS\s+NOT\s+NULL|IS\s+NULL|NOT\s+LIKE|NOT\s+IN|NOT\s+REGEXP_MATCH|REGEXP_MATCH|LIKE|IN|BETWEEN|DURING|!=|<=|>=|=|<|>)/gi;
+function escapeRegExp(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function withoutNullTest(query, field) {
+  const test = `${escapeRegExp(field)}\\s+IS\\s+(?:NOT\\s+)?NULL\\b`;
+  const dropped = query.replace(new RegExp(`\\bWHERE\\s+${test}\\s+AND\\s+`, "i"), "WHERE ").replace(new RegExp(`\\s+AND\\s+${test}`, "i"), "").replace(new RegExp(`\\s*\\bWHERE\\s+${test}`, "i"), "");
+  return mentions(selectClause(dropped), field) ? dropped : dropped.replace(/SELECT\s+/i, `SELECT ${field}, `);
+}
+function asListCondition(query, field) {
+  const condition = new RegExp(
+    `(?<![\\w.])${escapeRegExp(field)}\\s*(NOT\\s+IN\\b|IN\\b|!=|=)\\s*('[^']*'|\\([^)]*\\))`,
+    "i"
+  );
+  const match = query.match(condition);
+  if (!match) return null;
+  const [, operator = "", value = ""] = match;
+  const contains = /^(=|IN)$/i.test(operator.trim()) ? "CONTAINS ANY" : "CONTAINS NONE";
+  const values = value.startsWith("(") ? value : `(${value})`;
+  return query.replace(condition, `${field} ${contains} ${values}`);
+}
+function rejectListFieldOperator(query, customerId) {
+  const where = whereClause(query).replace(/'[^']*'/g, "''");
+  const refusals = [...where.matchAll(WHERE_OPERATOR)].map(([, field = "", operator = ""]) => ({
+    field: field.toLowerCase(),
+    operator: operator.toUpperCase().replace(/\s+/g, " ")
+  })).filter(({ field, operator }) => LIST_FIELDS.has(field) && !operator.startsWith("CONTAINS"));
+  const first = refusals[0];
+  if (!first) return null;
+  const fixed = refusals.reduce(
+    (corrected, { field, operator }) => corrected === null ? null : operator.startsWith("IS ") ? withoutNullTest(corrected, field) : asListCondition(corrected, field),
+    query
+  );
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_OPERATOR",
+      message: `${first.operator} cannot be used on ${first.field}: it is a list field, so Google would refuse this query.`,
+      fix: {
+        action: "change_operator",
+        ...fixed ? { correctedCommand: buildCommand2(fixed, customerId) } : {},
+        explanation: listFieldGuidance(first.field)
+      },
+      retryable: false
+    }
+  };
+}
+function rejectContainsCall(query, customerId) {
+  const containsMatch = query.match(/CONTAINS\s*\(\s*([^,]+),\s*'([^']+)'\s*\)/i);
+  if (!containsMatch) return null;
+  const field = containsMatch[1]?.trim();
+  const value = containsMatch[2] ?? "";
+  const fixed = query.replace(/CONTAINS\s*\(\s*[^,]+,\s*'[^']+'\s*\)/i, `${field} LIKE '%${value}%'`);
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_OPERATOR",
+      message: "GAQL does not support CONTAINS. Use LIKE with % wildcards.",
+      fix: {
+        action: "change_operator",
+        correctedCommand: buildCommand2(fixed, customerId),
+        explanation: "GAQL uses LIKE '%value%' for substring matching, not CONTAINS()"
+      },
+      retryable: false
+    }
+  };
+}
 function validatePreflight(query, customerId, limit) {
   const warnings = [];
   const corrected = query;
@@ -13104,29 +13289,6 @@ function validatePreflight(query, customerId, limit) {
       }
     };
   }
-  const containsMatch = corrected.match(/CONTAINS\s*\(\s*([^,]+),\s*'([^']+)'\s*\)/i);
-  if (containsMatch) {
-    const field = containsMatch[1]?.trim();
-    const value = containsMatch[2] ?? "";
-    const fixed = corrected.replace(/CONTAINS\s*\(\s*[^,]+,\s*'[^']+'\s*\)/i, `${field} LIKE '%${value}%'`);
-    return {
-      valid: false,
-      warnings: [],
-      error: {
-        ok: false,
-        error: {
-          code: "INVALID_OPERATOR",
-          message: "GAQL does not support CONTAINS. Use LIKE with % wildcards.",
-          fix: {
-            action: "change_operator",
-            correctedCommand: buildCommand2(fixed, customerId),
-            explanation: "GAQL uses LIKE '%value%' for substring matching, not CONTAINS()"
-          },
-          retryable: false
-        }
-      }
-    };
-  }
   const openDateMatch = corrected.match(/segments\.date\s*>=\s*'(\d{4}-\d{2}-\d{2})'/i);
   if (openDateMatch && !/BETWEEN/i.test(corrected)) {
     const startDate = openDateMatch[1] ?? "";
@@ -13153,10 +13315,10 @@ function validatePreflight(query, customerId, limit) {
       }
     };
   }
-  const duringRejection = rejectUnsupportedDuring(corrected, customerId);
-  if (duringRejection) return { valid: false, warnings: [], error: duringRejection };
-  const limitRejection = rejectOversizedLimit(corrected, customerId);
-  if (limitRejection) return { valid: false, warnings: [], error: limitRejection };
+  for (const reject of [rejectContainsCall, rejectListFieldOperator, rejectUnsupportedDuring, rejectOversizedLimit]) {
+    const rejection2 = reject(corrected, customerId);
+    if (rejection2) return { valid: false, warnings: [], error: rejection2 };
+  }
   if (/\bsegments\.conversion_action_name\b/i.test(corrected) && /\bmetrics\.cost_micros\b/i.test(corrected)) {
     return {
       valid: false,
@@ -33401,19 +33563,6 @@ function pageOf(args5) {
     ...size ? { pageSize: Number(size) } : {}
   };
 }
-function isWholePositive(raw) {
-  return /^[1-9]\d*$/.test(String(raw));
-}
-function paginationError(args5) {
-  if (args5.page !== void 0 && !isWholePositive(args5.page)) {
-    return `--page takes a page number of a list report (1, 2, \u2026), not "${String(args5.page)}". To narrow a report to one page of the site, pass --landing <internalId> (from \`baker analytics landings\`), or read one path with \`baker analytics page --path /pricing\`.`;
-  }
-  const size = args5["page-size"];
-  if (size !== void 0 && !isWholePositive(size)) {
-    return `--page-size takes a number of rows (1 to 200), not "${String(size)}".`;
-  }
-  return null;
-}
 function requestBody(args5, options) {
   const candidates = {
     preset: options.preset,
@@ -33478,11 +33627,6 @@ async function runPreset(args5, options) {
     });
     process.exit(1);
   }
-  const pagination = paginationError(args5);
-  if (pagination) {
-    writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: pagination } });
-    process.exit(1);
-  }
   try {
     const response = await apiPost("/api/analytics/query", requestBody(args5, options));
     const requestedPlatform = args5.platform === void 0 ? "" : String(args5.platform);
@@ -57541,7 +57685,7 @@ function mentionsInSource(source, names) {
   const out = [];
   for (const name of names) {
     const seen = /* @__PURE__ */ new Set();
-    for (const m of visible.matchAll(new RegExp(`\\b${escapeRegExp(name)}\\b`, "gi"))) {
+    for (const m of visible.matchAll(new RegExp(`\\b${escapeRegExp2(name)}\\b`, "gi"))) {
       const at = m.index ?? 0;
       if (tables.some(([from, to]) => at >= from && at < to)) continue;
       const start = sentenceStart(visible, at);
@@ -57570,7 +57714,7 @@ function blankHtmlKeepingOffsets(text2) {
   }
   return out.join("");
 }
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function detectSource(source) {
@@ -68628,36 +68772,19 @@ function findUnknownFlags(root, argv) {
   }
   return unknown;
 }
-var SYNONYMS = {
-  from: ["start-date", "start", "since"],
-  since: ["start-date", "start", "from"],
-  start: ["start-date", "since", "from"],
-  to: ["end-date", "end", "until"],
-  until: ["end-date", "end", "to"],
-  end: ["end-date", "until", "to"],
-  path: ["landing"],
-  url: ["landing"]
-};
 function closestFlag(unknown, command) {
   const accepted = acceptedNames(command);
   if (!accepted) {
     return null;
   }
   const name = unknown.replace(/^--/, "").split("=")[0] ?? "";
-  const synonym = SYNONYMS[name]?.find((candidate) => accepted.has(candidate));
-  if (synonym) {
-    return `--${synonym}`;
-  }
   const scored = [...accepted].filter((candidate) => !ALWAYS_ACCEPTED.has(candidate)).map((candidate) => ({
     candidate,
     prefix: sharedPrefix(name, candidate),
     distance: editDistance(name, candidate)
-  })).filter(({ prefix, distance }) => prefix >= 4 || distance <= typoBudget(name)).sort((a, b) => b.prefix - a.prefix || a.distance - b.distance);
+  })).filter(({ prefix, distance }) => prefix >= 4 || distance <= 3).sort((a, b) => b.prefix - a.prefix || a.distance - b.distance);
   return scored[0] ? `--${scored[0].candidate}` : null;
 }
-function typoBudget(name) {
-  return Math.max(1, Math.floor(name.length / 3));
-}
 function sharedPrefix(a, b) {
   let i = 0;
   while (i < a.length && i < b.length && a[i] === b[i]) {
@@ -68681,24 +68808,6 @@ function commandFor(root, argv) {
   const { command, resolved } = resolveCommand2(root, argv);
   return resolved ? command : null;
 }
-function suggestFlag(unknown, command) {
-  const flag = closestFlag(unknown, command);
-  if (!flag) {
-    return null;
-  }
-  const args5 = argsOf(command) ?? {};
-  const name = flag.slice(2);
-  const def = args5[name] ?? args5[camel(name)];
-  const described = def && typeof def === "object" ? def.description : void 0;
-  const description = typeof described === "string" ? described.split(/\.\s/)[0]?.trim().replace(/\.$/, "") : "";
-  return description ? { flag, description } : { flag };
-}
-function suggestionText(suggestion) {
-  if (!suggestion) {
-    return "";
-  }
-  return suggestion.description ? `Did you mean ${suggestion.flag}? It is described as: ${suggestion.description}. ` : `Did you mean ${suggestion.flag}? `;
-}
 var OUTPUT_EXPLANATION = "This command has no --output option: `--output json` is accepted by every command that prints the JSON envelope, and md or files only where `baker schema` lists `output`. Drop the option and read the default output. ";
 function unknownFlagEnvelope(unknown, commandPath, suggestion, hasSchema) {
   const list = unknown.join(", ");
@@ -68709,7 +68818,7 @@ function unknownFlagEnvelope(unknown, commandPath, suggestion, hasSchema) {
       message: `${list} ${unknown.length > 1 ? "are not options" : "is not an option"} of \`baker ${commandPath}\`.`,
       fix: {
         action: hasSchema ? "check_schema" : "check_help",
-        explanation: (unknown.some((flag) => flag === "--output" || flag.startsWith("--output=")) ? OUTPUT_EXPLANATION : "") + suggestionText(suggestion) + `Run \`${hasSchema ? `baker schema ${commandPath}` : `baker ${commandPath} --help`}\` to see every option this command takes. Do not re-run the same call: until this version an unrecognised option was accepted and ignored, so a command that looked like it had filtered or narrowed the result was in fact answering the unfiltered question.`
+        explanation: (unknown.some((flag) => flag === "--output" || flag.startsWith("--output=")) ? OUTPUT_EXPLANATION : "") + (suggestion ? `Did you mean ${suggestion}? ` : "") + `Run \`${hasSchema ? `baker schema ${commandPath}` : `baker ${commandPath} --help`}\` to see every option this command takes. Do not re-run the same call: until this version an unrecognised option was accepted and ignored, so a command that looked like it had filtered or narrowed the result was in fact answering the unfiltered question.`
       },
       retryable: false
     }
@@ -68739,7 +68848,7 @@ function refuseUnknownFlags(root, argv) {
   }
   const command = commandFor(root, argv);
   const first = unknown[0];
-  const suggestion = command && first ? suggestFlag(first, command) : null;
+  const suggestion = command && first ? closestFlag(first, command) : null;
   const path48 = commandPathOf(root, argv);
   process.stdout.write(
     `${JSON.stringify(unknownFlagEnvelope(unknown, path48, suggestion, findSchema(path48.split(" ")) !== void 0), null, 2)}