@koda-sl/baker-cli 0.515.0-dev.957976bb7 → 0.516.0

package/dist/rule-writes-K4P3XBJW.js

@@ -0,0 +1,525 @@
+import {
+  decimalMarkShown
+} from "./chunk-XOQNM7I4.js";
+import {
+  bareAccountId,
+  failWriteValidation,
+  requireTarget,
+  stageOp
+} from "./chunk-ILPHIYAL.js";
+import "./chunk-Q3GSVLE5.js";
+import "./chunk-GDFJOCDO.js";
+import "./chunk-M7QZSEHF.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import "./chunk-SCAGMX2I.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-QPESDKZC.js";
+import "./chunk-Y2JZX6JB.js";
+import "./chunk-6DPSWLGY.js";
+import "./chunk-E44NXCTL.js";
+import "./chunk-EJGAJHLB.js";
+import "./chunk-LNNTHEL7.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/rule-writes.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/ads/meta/rule-flags.ts
+var METRIC_ALIASES = {
+  cost_per_result: "cost_per",
+  cpr: "cost_per",
+  cost_per_lead: "cost_per_lead_fb",
+  cost_per_purchase: "cost_per_purchase_fb",
+  cost_per_add_to_cart: "cost_per_add_to_cart_fb",
+  cost_per_registration: "cost_per_complete_registration_fb",
+  roas: "website_purchase_roas",
+  purchase_roas: "website_purchase_roas",
+  spend: "spent",
+  amount_spent: "spent",
+  link_clicks: "link_click",
+  leads: "offsite_conversion.fb_pixel_lead",
+  purchases: "offsite_conversion.fb_pixel_purchase"
+};
+var CONDITION_HELP = 'write a condition as "cost_per_result>20", "ctr<0.8", "spend between 10 and 50" or "frequency outside 1 and 3" \u2014 money in the account currency, a dot or a comma for decimals (12.5 or 12,5)';
+function metric(raw) {
+  const key = raw.trim().toLowerCase();
+  const dot = key.lastIndexOf(".");
+  const prefix = dot > 0 && !key.startsWith("offsite_conversion") ? key.slice(0, dot + 1) : "";
+  const base = prefix ? key.slice(prefix.length) : key;
+  return `${prefix}${METRIC_ALIASES[base] ?? base}`;
+}
+function number(raw) {
+  const cleaned = raw.replace(/\s/g, "");
+  const mark = decimalMarkShown(cleaned) ?? (cleaned.includes(",") ? void 0 : ".");
+  if (!mark) {
+    throw new Error(
+      `"${raw}" is ambiguous \u2014 it could be ${cleaned.replace(/,/g, "")} or ${cleaned.replace(",", ".")}; write it with a dot for decimals and no thousands separator (1234 or 1.234)`
+    );
+  }
+  const plain = cleaned.split(mark === "," ? "." : ",").join("").replace(",", ".");
+  const value = plain === "" ? Number.NaN : Number(plain);
+  if (!Number.isFinite(value)) throw new Error(`"${raw}" is not a number \u2014 ${CONDITION_HELP}`);
+  return value;
+}
+function ruleConditionFromFlag(raw) {
+  const range = /^\s*([\w.:]+)\s+(between|outside)\s+(-?[\d.,]+)\s+and\s+(-?[\d.,]+)\s*$/i.exec(raw);
+  if (range?.[1] && range[2] && range[3] && range[4]) {
+    return {
+      field: metric(range[1]),
+      operator: range[2].toLowerCase() === "between" ? "IN_RANGE" : "NOT_IN_RANGE",
+      value: [number(range[3]), number(range[4])]
+    };
+  }
+  const compare = /^\s*([\w.:]+)\s*(>|<|=|\babove\b|\bbelow\b)\s*(-?[\d.,]+)\s*$/i.exec(raw);
+  if (compare?.[1] && compare[2] && compare[3]) {
+    const word = compare[2].toLowerCase();
+    const operator = word === ">" || word === "above" ? "GREATER_THAN" : word === "<" || word === "below" ? "LESS_THAN" : "EQUAL";
+    return { field: metric(compare[1]), operator, value: number(compare[3]) };
+  }
+  throw new Error(`could not read --when "${raw}" \u2014 ${CONDITION_HELP}`);
+}
+var LEVELS = {
+  ad: "AD",
+  ads: "AD",
+  adset: "ADSET",
+  adsets: "ADSET",
+  "ad-set": "ADSET",
+  campaign: "CAMPAIGN",
+  campaigns: "CAMPAIGN"
+};
+var EVALUATION_FLAGS = [
+  "apply-to",
+  "ids",
+  "in-campaigns",
+  "in-adsets",
+  "name-contains",
+  "when",
+  "window",
+  "realtime"
+];
+var EXECUTION_FLAGS = ["action", "by", "cap", "max-times", "every", "notify-user-ids"];
+var SCHEDULE_FLAGS = ["schedule", "at", "between", "days"];
+function given(flags, names) {
+  return names.some((name) => {
+    const value = flags[name];
+    return Array.isArray(value) ? value.length > 0 : value !== void 0 && value !== false && value !== "";
+  });
+}
+function ruleLevel(flags) {
+  const raw = flags["apply-to"];
+  if (!raw) return isRotate(flags) ? "AD" : void 0;
+  const level = LEVELS[raw.toLowerCase()];
+  if (!level) throw new Error(`--apply-to takes ad, adset or campaign \u2014 not "${raw}"`);
+  return level;
+}
+function listFilter(field, ids) {
+  return ids?.length ? [{ field, operator: "IN", value: ids }] : [];
+}
+function isRotate(flags) {
+  return flags.action?.toLowerCase() === "rotate";
+}
+function scopeFilters(flags, level) {
+  return [
+    ...level ? [{ field: "entity_type", operator: "EQUAL", value: level }] : [],
+    ...listFilter(isRotate(flags) ? "adset.id" : "id", flags.ids),
+    ...listFilter("campaign.id", flags["in-campaigns"]),
+    ...listFilter("adset.id", flags["in-adsets"]),
+    ...flags["name-contains"] ? [{ field: "name", operator: "CONTAIN", value: flags["name-contains"] }] : []
+  ];
+}
+function evaluationFromFlags(flags) {
+  const level = ruleLevel(flags);
+  if (!level && !flags.ids?.length) {
+    throw new Error(
+      "say what the rule watches: --apply-to ad|adset|campaign (every one in the account), plus --ids to name them"
+    );
+  }
+  const conditions = (flags.when ?? []).map(ruleConditionFromFlag);
+  const [first, ...rest] = conditions;
+  const trigger = flags.realtime ? first : void 0;
+  if (flags.realtime && !trigger) throw new Error("--realtime needs a --when condition to react to");
+  const filters = scopeFilters(flags, level);
+  if (conditions.length > 0 || flags.window) {
+    const preset = (flags.window ?? (flags.realtime ? "TODAY" : "LAST_7D")).toUpperCase();
+    filters.push({ field: "time_preset", operator: "EQUAL", value: preset });
+  }
+  filters.push(...trigger ? rest : conditions);
+  return {
+    evaluation_type: trigger ? "TRIGGER" : "SCHEDULE",
+    filters,
+    ...trigger ? { trigger: { type: "STATS_CHANGE", ...trigger } } : {}
+  };
+}
+var ACTIONS = {
+  pause: { type: "PAUSE" },
+  unpause: { type: "UNPAUSE" },
+  "turn-on": { type: "UNPAUSE" },
+  notify: { type: "NOTIFICATION" },
+  "raise-budget": { type: "CHANGE_BUDGET", sign: 1 },
+  "lower-budget": { type: "CHANGE_BUDGET", sign: -1 },
+  "raise-bid": { type: "CHANGE_BID", sign: 1 },
+  "lower-bid": { type: "CHANGE_BID", sign: -1 },
+  rotate: { type: "ROTATE" }
+};
+function minutes(raw) {
+  const match = /^\s*(\d+)\s*(m|min|h|d)?\s*$/i.exec(raw);
+  if (!match?.[1]) throw new Error(`--every takes minutes, or hours/days like 12h or 7d \u2014 not "${raw}"`);
+  const unit = (match[2] ?? "m").toLowerCase();
+  return Number(match[1]) * (unit === "d" ? 1440 : unit === "h" ? 60 : 1);
+}
+function changeSpec(flags, sign) {
+  if (!flags.by)
+    throw new Error(`--action ${flags.action} needs --by: a percentage like 20% or an amount in the account currency`);
+  const percent = flags.by.trim().endsWith("%");
+  const amount = number(flags.by.replace("%", "")) * sign;
+  return {
+    amount,
+    unit: percent ? "PERCENTAGE" : "ACCOUNT_CURRENCY",
+    ...flags.cap ? { limit: number(flags.cap) } : {}
+  };
+}
+function executionFromFlags(flags, level) {
+  const action = flags.action ? ACTIONS[flags.action.toLowerCase()] : void 0;
+  if (!action) {
+    throw new Error(
+      `--action takes ${Object.keys(ACTIONS).join(", ")}${flags.action ? ` \u2014 not "${flags.action}"` : ""}`
+    );
+  }
+  const type = action.type === "CHANGE_BUDGET" && level === "CAMPAIGN" ? "CHANGE_CAMPAIGN_BUDGET" : action.type;
+  const options = [];
+  if (action.sign) options.push({ field: "change_spec", operator: "EQUAL", value: changeSpec(flags, action.sign) });
+  if (flags["max-times"])
+    options.push({ field: "execution_count_limit", operator: "EQUAL", value: number(flags["max-times"]) });
+  if (flags.every) options.push({ field: "action_frequency", operator: "EQUAL", value: minutes(flags.every) });
+  if (flags["notify-user-ids"]?.length)
+    options.push({ field: "user_ids", operator: "EQUAL", value: flags["notify-user-ids"] });
+  return { execution_type: type, ...options.length > 0 ? { execution_options: options } : {} };
+}
+var DAY_NUMBERS = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+function clockMinutes(raw) {
+  const match = /^\s*(\d{1,2}):(\d{2})\s*$/.exec(raw);
+  if (!match?.[1] || !match[2]) throw new Error(`times are HH:MM on the half hour, like 09:30 \u2014 not "${raw}"`);
+  return Number(match[1]) * 60 + Number(match[2]);
+}
+function days(raw) {
+  if (!raw) return void 0;
+  return raw.split(",").map((day) => {
+    const value = DAY_NUMBERS[day.trim().slice(0, 3).toLowerCase()];
+    if (value === void 0) throw new Error(`--days takes mon,tue,wed,thu,fri,sat,sun \u2014 not "${day}"`);
+    return value;
+  });
+}
+var SCHEDULE_TYPES = {
+  daily: "DAILY",
+  hourly: "HOURLY",
+  "half-hourly": "SEMI_HOURLY",
+  "semi-hourly": "SEMI_HOURLY",
+  custom: "CUSTOM"
+};
+function scheduleFromFlags(flags) {
+  const custom = Boolean(flags.at?.length || flags.between || flags.days);
+  const type = flags.schedule ? SCHEDULE_TYPES[flags.schedule.toLowerCase()] : custom ? "CUSTOM" : "DAILY";
+  if (!type) throw new Error(`--schedule takes daily, hourly, half-hourly or custom \u2014 not "${flags.schedule}"`);
+  if (type !== "CUSTOM" && custom) {
+    throw new Error(
+      `--at, --between and --days set a custom timetable, which --schedule ${flags.schedule} does not take \u2014 use --schedule custom (or leave --schedule out)`
+    );
+  }
+  if (type !== "CUSTOM") return { schedule_type: type };
+  const dayList = days(flags.days);
+  const withDays = dayList ? { days: dayList } : {};
+  const items = (flags.at ?? []).map((at) => ({
+    start_minute: clockMinutes(at),
+    ...withDays
+  }));
+  if (flags.between) {
+    const [from, to] = flags.between.split("-");
+    if (!from || !to) throw new Error(`--between takes a time range like 09:00-17:00 \u2014 not "${flags.between}"`);
+    items.push({ start_minute: clockMinutes(from), end_minute: clockMinutes(to), ...withDays });
+  }
+  return { schedule_type: "CUSTOM", schedule: items.length > 0 ? items : [withDays] };
+}
+var READ_ONLY_RULE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "account_id",
+  "created_time",
+  "updated_time",
+  "created_by",
+  "disable_error_code",
+  "description",
+  "currencyCode"
+]);
+function ruleFileForStaging(raw, { update = false } = {}) {
+  const unwrapped = raw && typeof raw === "object" && !Array.isArray(raw) && "data" in raw ? raw.data : raw;
+  const list = Array.isArray(unwrapped) ? unwrapped : [unwrapped];
+  if (list.length !== 1) {
+    throw new Error(`holds ${list.length} rules \u2014 keep the one to stage`);
+  }
+  const rule = list[0];
+  if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+    throw new Error("must contain a JSON object with the rule");
+  }
+  return Object.fromEntries(
+    Object.entries(rule).filter(([key]) => !READ_ONLY_RULE_KEYS.has(key) && !(update && key === "status"))
+  );
+}
+function rulePayloadFromFlags(flags, { update = false } = {}) {
+  if (flags.realtime && given(flags, SCHEDULE_FLAGS)) {
+    throw new Error(
+      "--realtime rules react the moment a metric changes and run on no schedule \u2014 drop --schedule/--at/--between/--days, or drop --realtime"
+    );
+  }
+  const evaluation = !update || given(flags, EVALUATION_FLAGS) ? evaluationFromFlags(flags) : void 0;
+  const level = ruleLevel(flags);
+  const execution = !update || given(flags, EXECUTION_FLAGS) ? executionFromFlags(flags, level) : void 0;
+  const realtime = evaluation?.evaluation_type === "TRIGGER";
+  const schedule = !realtime && (!update || given(flags, SCHEDULE_FLAGS)) ? scheduleFromFlags(flags) : void 0;
+  return {
+    ...flags.name ? { name: flags.name } : {},
+    ...flags.status ? { status: flags.status.toUpperCase() } : {},
+    ...evaluation ? { evaluation_spec: evaluation } : {},
+    ...execution ? { execution_spec: execution } : {},
+    ...schedule ? { schedule_spec: schedule } : {}
+  };
+}
+
+// src/commands/ads/meta/rule-writes.ts
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads meta draft`.";
+var ruleArgs = {
+  "account-id": { type: "string", description: "Numeric account ID or act_N" },
+  name: { type: "string", description: "Rule name, shown in Ads Manager \u2192 Automated rules" },
+  "apply-to": {
+    type: "string",
+    description: "What the rule watches and acts on: ad | adset | campaign. Alone, it means every one in the account."
+  },
+  ids: {
+    type: "string",
+    description: "Only these ads / ad sets / campaigns (repeatable or comma-separated; meta_temp_* refs from this chat work). With --action rotate: the ad sets whose ads take turns"
+  },
+  "in-campaigns": { type: "string", description: "Only what sits in these campaigns (repeatable or comma-separated)" },
+  "in-adsets": { type: "string", description: "Only what sits in these ad sets (repeatable or comma-separated)" },
+  "name-contains": { type: "string", description: "Only objects whose name contains this text" },
+  when: {
+    type: "string",
+    description: 'A condition, repeatable (all must hold): "cost_per_result>20", "ctr<0.8", "spend between 10 and 50", "frequency outside 1 and 3". Money in the account currency. Metrics: cost_per_result, cpa, cpc, cpm, ctr, frequency, spend, results, impressions, reach, roas, cost_per_lead, cost_per_purchase, or any Meta rule field.'
+  },
+  window: {
+    type: "string",
+    description: "Time range the metrics are read over (default LAST_7D \u2014 the last 7 full days): TODAY, YESTERDAY, LAST_3D, LAST_7D, LAST_14D, LAST_30D, LAST_7_DAYS (today included), LIFETIME, THIS_MONTH"
+  },
+  realtime: {
+    type: "boolean",
+    description: "React the moment the first --when condition becomes true (a trigger rule) instead of on a schedule. Only pause, unpause and notify; the window must include today."
+  },
+  action: {
+    type: "string",
+    description: "pause | unpause | notify | raise-budget | lower-budget | raise-bid | lower-bid | rotate"
+  },
+  by: { type: "string", description: "For a budget or bid change: 20% or an amount in the account currency" },
+  cap: {
+    type: "string",
+    description: "Highest (raise) or lowest (lower) the budget or bid may reach, account currency"
+  },
+  "max-times": { type: "string", description: "Change each object at most this many times" },
+  every: { type: "string", description: "Wait at least this long before changing the same object again: 90, 12h, 7d" },
+  "notify-user-ids": {
+    type: "string",
+    description: "Facebook user ids to notify (default: whoever connected Meta); repeatable or comma-separated"
+  },
+  schedule: { type: "string", description: "daily (default) | hourly | half-hourly | custom" },
+  at: { type: "string", description: "Custom schedule: run at HH:MM (half hours), repeatable" },
+  between: { type: "string", description: "Custom schedule: run every 30 minutes in this window, e.g. 09:00-17:00" },
+  days: { type: "string", description: "Custom schedule: only these days, e.g. mon,wed,fri" },
+  file: {
+    type: "string",
+    description: "JSON with the full rule \u2014 {name, status, evaluation_spec, execution_spec, schedule_spec} in Meta's shape. What `rules --rule-id <id>` prints can be saved and passed as it is (its id and timestamps are left out). Flags override its name and status."
+  }
+};
+function schemaArgs(args) {
+  return Object.fromEntries(Object.entries(args).map(([key, arg]) => [key, { ...arg, required: false }]));
+}
+function listValues(rawArgs, flag, parsed) {
+  return repeatedValues(rawArgs, flag, parsed).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+}
+function ruleFlagsFromArgs(args, rawArgs) {
+  const text = (key) => typeof args[key] === "string" && args[key] !== "" ? String(args[key]) : void 0;
+  return {
+    name: text("name"),
+    status: text("status"),
+    "apply-to": text("apply-to"),
+    ids: listValues(rawArgs, "ids", args.ids),
+    "in-campaigns": listValues(rawArgs, "in-campaigns", args["in-campaigns"]),
+    "in-adsets": listValues(rawArgs, "in-adsets", args["in-adsets"]),
+    "name-contains": text("name-contains"),
+    when: repeatedValues(rawArgs, "when", args.when),
+    window: text("window"),
+    realtime: args.realtime === true,
+    action: text("action"),
+    by: text("by"),
+    cap: text("cap"),
+    "max-times": text("max-times"),
+    every: text("every"),
+    "notify-user-ids": listValues(rawArgs, "notify-user-ids", args["notify-user-ids"]),
+    schedule: text("schedule"),
+    at: repeatedValues(rawArgs, "at", args.at),
+    between: text("between"),
+    days: listValues(rawArgs, "days", args.days).join(",") || void 0
+  };
+}
+function payloadOrFail(flags, update) {
+  try {
+    return rulePayloadFromFlags(flags, { update });
+  } catch (err) {
+    failWriteValidation(err instanceof Error ? err.message : String(err));
+  }
+}
+function loadRuleFile(path, update) {
+  if (typeof path !== "string" || path.length === 0) {
+    return {};
+  }
+  try {
+    return ruleFileForStaging(JSON.parse(readFileSync(path, "utf8")), { update });
+  } catch (err) {
+    failWriteValidation(`${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function rulePayload(args, rawArgs, update) {
+  const file = loadRuleFile(args.file, update);
+  const flags = ruleFlagsFromArgs(args, rawArgs);
+  const fromFile = Object.keys(file).length > 0;
+  const fromFlags = fromFile ? payloadOrFail(flags, true) : payloadOrFail(flags, update);
+  return { ...file, ...fromFlags };
+}
+registerSchema({
+  command: "ads.meta.rules.create",
+  description: `Stage a new Meta automated rule \u2014 it is created at publish and then runs on Meta, unattended. Shorthand: --apply-to ad|adset|campaign [--ids \u2026] --when "cost_per_result>20" [--window LAST_7D] --action pause|unpause|notify|raise-budget|lower-budget|raise-bid|lower-bid|rotate [--by 20%] [--cap 500] [--schedule daily|hourly|custom --at 09:00 --days mon,fri] [--realtime]. Or --file with the full rule in Meta's shape. Fields Meta compares: Insights metrics (cost_per, spent, results, impressions, reach, frequency, cpc, cpm, ctr, cpa, link_ctr, website_purchase_roas, cost_per_lead_fb, \u2026) and metadata (name, daily_budget, hours_since_creation, effective_status, \u2026), optionally prefixed ad./adset./campaign. Starts switched on unless --status DISABLED.`,
+  args: schemaArgs({ ...ruleArgs, status: { type: "string", description: "ENABLED (default) or DISABLED" } })
+});
+var rulesCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage a new Meta automated rule. ${STAGED_NOTE}
+It runs on Meta from publish on, with nobody watching \u2014 say what it will do back to the user before publishing.
+Examples:
+  baker ads meta rules create --name "Stop expensive ads" --apply-to ad --when "cost_per_result>20" --action pause
+  baker ads meta rules create --name "Scale winners" --apply-to adset --in-campaigns 6123 --when "roas>3" --when "spend>50" --window LAST_3D --action raise-budget --by 20% --cap 500 --max-times 3
+  baker ads meta rules create --name "CPM alarm" --apply-to campaign --when "cpm>15" --window TODAY --action notify --realtime
+  baker ads meta rules create --file rule.json`
+  },
+  args: { ...ruleArgs, status: { type: "string", description: "ENABLED (default) or DISABLED" } },
+  run: async ({ args, rawArgs }) => {
+    const accountId = bareAccountId(args);
+    await stageOp({ kind: "adRule.create", accountId, payload: rulePayload(args, rawArgs, false) });
+  }
+});
+registerSchema({
+  command: "ads.meta.rules.update",
+  description: "Stage a change to a live rule (or amend one staged in this chat by its meta_temp_* ref). Each part you change is replaced whole: any of --apply-to/--ids/--in-*/--name-contains/--when/--window/--realtime rebuilds what it checks, --action/--by/--cap/--max-times/--every/--notify-user-ids what it does, --schedule/--at/--between/--days when it runs. Restate every condition you keep \u2014 read it first with `rules --rule-id`.",
+  args: { id: { type: "positional", description: "Rule id", required: true }, ...schemaArgs(ruleArgs) }
+});
+var rulesUpdateCommand = defineCommand({
+  meta: {
+    name: "update",
+    description: `Stage a change to a rule. ${STAGED_NOTE}
+Each part you change is replaced whole \u2014 restate every condition you keep (read the rule first: \`rules --rule-id <id>\`). Switch with enable/disable; remove with delete.
+Example: baker ads meta rules update 1132635173044914 --apply-to ad --when "cost_per_result>25" --window LAST_7D`
+  },
+  args: { id: { type: "positional", description: "Rule id or meta_temp_* ref", required: true }, ...ruleArgs },
+  run: async ({ args, rawArgs }) => {
+    const accountId = bareAccountId(args);
+    const target = requireTarget(args, "rule");
+    const payload = rulePayload(args, rawArgs, true);
+    if (payload.status === "DELETED") {
+      failWriteValidation(
+        "update does not delete \u2014 use `baker ads meta rules delete <id>` if the user asked to remove it"
+      );
+    }
+    await stageOp({ kind: "adRule.update", accountId, target, payload });
+  }
+});
+var STATUS_COMMANDS = {
+  enable: { status: "ENABLED", note: "It starts running on its schedule from publish on." },
+  disable: { status: "DISABLED", note: "It stops running and keeps its settings; enable brings it back." },
+  delete: {
+    status: "DELETED",
+    note: "Deleting is permanent \u2014 Meta removes the rule from the account. Prefer disable unless the user asked to delete it."
+  }
+};
+function statusCommand(name) {
+  const { status, note } = STATUS_COMMANDS[name];
+  registerSchema({
+    command: `ads.meta.rules.${name}`,
+    description: `Stage ${name} for an automated rule. ${note}`,
+    args: {
+      id: { type: "positional", description: "Rule id", required: true },
+      "account-id": { type: "string", description: "Meta ad account ID (act_123)", required: false }
+    }
+  });
+  return defineCommand({
+    meta: { name, description: `Stage ${name} for an automated rule. ${note} ${STAGED_NOTE}` },
+    args: { id: { type: "positional", description: "Rule id", required: true }, "account-id": ruleArgs["account-id"] },
+    run: async ({ args }) => {
+      const accountId = bareAccountId(args);
+      await stageOp({
+        kind: "adRule.update",
+        accountId,
+        target: requireTarget(args, "rule"),
+        payload: { status }
+      });
+    }
+  });
+}
+var rulesEnableCommand = statusCommand("enable");
+var rulesDisableCommand = statusCommand("disable");
+var rulesDeleteCommand = statusCommand("delete");
+registerSchema({
+  command: "ads.meta.rules.run",
+  description: "Stage running an automated rule once, at publish \u2014 it acts on whatever matches it then, whatever its schedule and even while it is off. Check what it would act on first with `rules preview <id>`.",
+  args: {
+    id: { type: "positional", description: "Rule id", required: true },
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)", required: false }
+  }
+});
+var rulesRunCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: `Stage running a rule once, at publish. ${STAGED_NOTE}
+The rule acts on whatever matches it when the chat is published (pauses, budget changes, notifications) \u2014 Meta runs it then, whatever its schedule, even while it is off. Start here: baker ads meta rules preview <id>, then baker ads meta rules history --rule-id <id> after publishing.
+Example: baker ads meta rules run 1132635173044914`
+  },
+  args: { id: { type: "positional", description: "Rule id", required: true }, "account-id": ruleArgs["account-id"] },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const target = requireTarget(args, "rule");
+    if (target.startsWith("meta_temp_")) {
+      failWriteValidation("a rule this chat creates exists only at publish \u2014 run it in a later chat, once it is live");
+    }
+    await stageOp({ kind: "adRule.update", accountId, target, payload: { run_now: true } });
+  }
+});
+export {
+  ruleFlagsFromArgs,
+  rulesCreateCommand,
+  rulesDeleteCommand,
+  rulesDisableCommand,
+  rulesEnableCommand,
+  rulesRunCommand,
+  rulesUpdateCommand
+};
+//# sourceMappingURL=rule-writes-K4P3XBJW.js.map

package/dist/rules-34BQAWU3.js

@@ -0,0 +1,99 @@
+import {
+  readCreativeSpecs,
+  rulesHints,
+  rulesView,
+  waiverCounts
+} from "./chunk-QVQKCVP7.js";
+import {
+  readAllRules
+} from "./chunk-QIOFOD4K.js";
+import "./chunk-A3IQAONL.js";
+import "./chunk-3YJNSUNF.js";
+import "./chunk-E44NXCTL.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-EJGAJHLB.js";
+import {
+  selectRules
+} from "./chunk-7HZSORAB.js";
+import "./chunk-MCJ5I5LR.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-PC3FJEZH.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/rules.ts
+import { defineCommand } from "citty";
+var LIST_DESCRIPTION = `The company's standing rules for every ad: the brand's own (BRAND.md) and the ones a person taught, each with its id, strength (never | must | prefer), what it is about, its words, the person's own words and where it came from. \`baker creatives brief\` carries them too.
+Start here: baker creatives rules list
+  baker creatives rules list --kind video --product cubbo-engage   # the rules one ad is held to
+  baker creatives rules list --all                                 # retired ones and every scope too`;
+var LIST_ARGS = {
+  kind: {
+    type: "string",
+    description: "static | video: only the rules an ad of this kind is held to",
+    required: false
+  },
+  product: {
+    type: "string",
+    description: "A product slug (src/content/products/<slug>.md): only the rules an ad of it is held to",
+    required: false
+  },
+  all: {
+    type: "boolean",
+    description: "Every rule, retired ones and every scope included",
+    required: false,
+    default: false
+  },
+  full: { type: "boolean", description: "Each rule and the person's words whole", required: false, default: false }
+};
+registerSchema({ command: "creatives.rules.list", description: LIST_DESCRIPTION, args: LIST_ARGS });
+var listCommand = defineCommand({
+  meta: { name: "list", description: LIST_DESCRIPTION },
+  args: LIST_ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const kind = args.kind === "static" || args.kind === "video" ? args.kind : void 0;
+    const product = typeof args.product === "string" && args.product ? args.product : void 0;
+    const [rules, specs] = await Promise.all([readAllRules(root), readCreativeSpecs(root)]);
+    const active = selectRules(rules, { ...kind ? { kind } : {}, ...product ? { product } : {} });
+    const shown = args.all === true ? rules : active;
+    const hints = rulesHints(active, waiverCounts(specs));
+    writeJson({
+      ok: true,
+      data: { rules: rulesView(shown, { full: args.full === true }), active: active.length, total: rules.length },
+      ...hints.length > 0 ? { hints } : {}
+    });
+  }
+});
+var rulesCommand = defineCommand({
+  meta: {
+    name: "rules",
+    description: "The company's standing rules for every ad: list them, add one the person agreed to, retire one."
+  },
+  subCommands: {
+    list: listCommand,
+    add: () => import("./rules-add-CM5XUYNS.js").then((m) => m.rulesAddCommand),
+    retire: () => import("./rules-add-CM5XUYNS.js").then((m) => m.rulesRetireCommand)
+  },
+  default: "list"
+});
+export {
+  rulesCommand
+};
+//# sourceMappingURL=rules-34BQAWU3.js.map