@koda-sl/baker-cli 0.452.0 → 0.453.0-dev.914a088e4

package/dist/chunk-Q3RKWCVL.js

@@ -0,0 +1,23 @@
+import {
+  creativesRunResponseSchema
+} from "./chunk-IDYAVGCS.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-PCKVSSVT.js";
+
+// src/commands/canvas/run-history.ts
+async function fetchRunRecord(runId, post = apiPost) {
+  try {
+    const response = await post("/api/creatives/run", { runId });
+    return creativesRunResponseSchema.parse(response).data;
+  } catch (e) {
+    if (e instanceof ApiError && e.code === "NOT_FOUND") return null;
+    throw e;
+  }
+}
+
+export {
+  fetchRunRecord
+};
+//# sourceMappingURL=chunk-Q3RKWCVL.js.map

package/dist/chunk-QCPZVAKJ.js

@@ -0,0 +1,106 @@
+import {
+  apiGet
+} from "./chunk-PCKVSSVT.js";
+
+// src/commands/testimonials/emptyCorpusHints.ts
+function resolveEmptyReason({
+  resultCount,
+  activeFilters,
+  sourceCount
+}) {
+  if (resultCount > 0) {
+    return null;
+  }
+  if (activeFilters.length > 0) {
+    return "filtered_out";
+  }
+  return sourceCount === 0 ? "no_corpus_connected" : "corpus_empty";
+}
+var NO_CORPUS_EXIT = "Testimonials are ingested from the client's public review pages \u2014 an agent cannot write one \u2014 so no rewording will find quotes. If the user named the client's own review page (Google Maps, Trustpilot, Yelp, Tripadvisor, G2, Capterra, Amazon, App Store, Google Play), add it with `baker testimonials sources add <link>` \u2014 its reviews arrive over the next minutes, not in this turn. Stop searching and source proof another way: a result or case study the client already published, a named-customer logo (`baker images logo`), or a founder claim attributed as a claim. Otherwise ship without a testimonial block and file the gap: `baker actions create --name \"Collect customer quotes for <page>\" --priority medium --tags <slug>`. Never invent, paraphrase-into-existence, or pad with unrelated praise.";
+function emptyReasonDetail(reason, sourceCount, activeFilters) {
+  if (reason === "filtered_out") {
+    return `No rows matched, and ${activeFilters.join(", ")} narrowed this read. The corpus was not checked \u2014 drop every filter to see whether the library itself is empty.`;
+  }
+  if (reason === "no_corpus_connected") {
+    return "This company has no review source connected \u2014 checked against its source list, not inferred from the empty result.";
+  }
+  return `${sourceCount} review source${sourceCount === 1 ? " is" : "s are"} connected but hold no testimonials yet \u2014 the source is there, the rows are not. Ingestion may still be running.`;
+}
+function morePagesHint(resultCount, cursor) {
+  const found = resultCount === 0 ? "This page held no matches" : `This page held ${resultCount}`;
+  return `${found}, and the library continues past it \u2014 so this is one page, not the client's whole set. Do not report it as the corpus and do not conclude anything is missing from it. Read the next page with \`baker testimonials list --cursor ${cursor}\` (same filters), or go straight at the rows you want with \`baker testimonials search <query>\`.`;
+}
+function endOfWalkHint(command) {
+  const noun = command === "search" ? "results" : "rows";
+  return `That was the end of the library \u2014 no more ${noun} past the page before this one. Nothing here says the corpus is empty (the earlier pages held it), so answer from what those pages returned rather than re-reading.`;
+}
+async function measureEmptyCorpus({
+  command,
+  resultCount,
+  activeFilters,
+  nextCursor = null,
+  continued = false
+}) {
+  if (nextCursor) {
+    return { hints: [morePagesHint(resultCount, nextCursor)] };
+  }
+  if (resultCount > 0) {
+    return { hints: [] };
+  }
+  if (continued) {
+    return { hints: [endOfWalkHint(command)] };
+  }
+  if (activeFilters.length > 0) {
+    const reason2 = "filtered_out";
+    return {
+      hints: emptyCorpusHints({ command, reason: reason2, sourceCount: 0, activeFilters }),
+      empty: { reason: reason2, detail: emptyReasonDetail(reason2, 0, activeFilters) }
+    };
+  }
+  let sourceCount;
+  try {
+    const sources = await apiGet("/api/testimonials/sources");
+    sourceCount = Array.isArray(sources) ? sources.length : 0;
+  } catch {
+    return {
+      hints: [
+        "No rows, and the check for connected review sources failed \u2014 so this is NOT evidence that the client has no reviews. Do not record an absence you could not verify. Re-run once; if it fails again, say the library could not be read rather than that it is empty."
+      ]
+    };
+  }
+  const reason = resolveEmptyReason({ resultCount, activeFilters, sourceCount });
+  if (reason === null) {
+    return { hints: [] };
+  }
+  return {
+    hints: emptyCorpusHints({ command, reason, sourceCount, activeFilters }),
+    empty: { reason, detail: emptyReasonDetail(reason, sourceCount, activeFilters) }
+  };
+}
+function emptyCorpusHints({
+  command,
+  reason,
+  sourceCount,
+  activeFilters
+}) {
+  if (reason === null) {
+    return [];
+  }
+  if (reason === "filtered_out") {
+    return [
+      `No rows \u2014 ${activeFilters.join(", ")} narrowed this. Drop every filter and re-run once before touching the query; a filter combination and an empty library look identical from here.`
+    ];
+  }
+  const lead = command === "search" ? "No hits" : "No rows";
+  if (reason === "no_corpus_connected") {
+    return [`${lead}, and this company's source list is empty: there is no review corpus to search. ${NO_CORPUS_EXIT}`];
+  }
+  return [
+    `${lead}. ${sourceCount} review source${sourceCount === 1 ? " is" : "s are"} connected but no testimonials have landed yet \u2014 so this is a timing or ingestion gap, not a missing connection, and re-querying will not change it. Ingestion may still be running: say so rather than reporting the client has no reviews. ${NO_CORPUS_EXIT}`
+  ];
+}
+
+export {
+  measureEmptyCorpus
+};
+//# sourceMappingURL=chunk-QCPZVAKJ.js.map

package/dist/chunk-QPZNLG7Y.js

@@ -0,0 +1,96 @@
+import {
+  loadCompositionMeta
+} from "./chunk-SDVJFN5Q.js";
+import {
+  parseRefExpr
+} from "./chunk-ERVDEVLC.js";
+import {
+  resolveAdaptFormats
+} from "./chunk-CAMX6OHF.js";
+
+// src/commands/canvas/output-ratio.ts
+import { readFile } from "fs/promises";
+import path from "path";
+function definitionFormats(markdown) {
+  const front = markdown.match(/^---\n([\s\S]*?)\n---/)?.[1];
+  if (!front) return [];
+  const clean = (s) => s.trim().replace(/^["']|["']$/g, "");
+  const flow = front.match(/^formats:\s*\[([^\]]*)\]/m);
+  if (flow) return (flow[1] ?? "").split(",").map(clean).filter(Boolean);
+  const block = front.match(/^formats:\s*\n((?:\s+-\s+.*\n?)+)/m);
+  if (!block) return [];
+  return (block[1] ?? "").split("\n").map((l) => l.replace(/^\s+-\s+/, "")).map(clean).filter(Boolean);
+}
+function reduce(width, height) {
+  const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+  const d = gcd(width, height);
+  return `${width / d}:${height / d}`;
+}
+async function ratiosOf(nodes, id, seen) {
+  const node = nodes.get(id);
+  if (!node || seen.has(id)) return null;
+  seen.add(id);
+  const p = node.params ?? {};
+  switch (node.type) {
+    case "image_generate":
+      return typeof p.aspect_ratio === "string" ? [p.aspect_ratio] : null;
+    case "image_aspect_adapt":
+      return [...resolveAdaptFormats(p)];
+    case "hyperframe_snapshot": {
+      if (typeof p.composition !== "string") return null;
+      const meta = await loadCompositionMeta(p.composition).catch(() => null);
+      return meta ? [reduce(meta.width, meta.height)] : null;
+    }
+    case "collect": {
+      const images = node.inputs?.images;
+      if (!Array.isArray(images)) return null;
+      const out = [];
+      for (const entry of images) {
+        const ref = typeof entry === "string" ? parseRefExpr(entry) : null;
+        if (!ref || ref.kind !== "ref") return null;
+        const upstream = await ratiosOf(nodes, ref.nodeId, seen);
+        if (!upstream) return null;
+        out.push(ref.index !== void 0 && upstream.length > 1 ? upstream[ref.index] ?? "" : upstream[0] ?? "");
+      }
+      return out.filter(Boolean);
+    }
+    default:
+      return null;
+  }
+}
+async function producedRatios(canvas) {
+  const c = canvas;
+  if (!Array.isArray(c?.nodes) || typeof c?.output?.node !== "string") return null;
+  const nodes = new Map(c.nodes.flatMap((n) => typeof n.id === "string" ? [[n.id, n]] : []));
+  return ratiosOf(nodes, c.output.node, /* @__PURE__ */ new Set());
+}
+function value(ratio) {
+  const [w, h] = ratio.split(":").map(Number);
+  return w && h ? w / h : null;
+}
+function outputRatioWarnings(declared, produced) {
+  if (!produced || produced.length === 0) return [];
+  const shapes = produced.flatMap((r) => value(r) ?? []);
+  return declared.flatMap((format) => {
+    const want = value(format);
+    if (want === null || shapes.some((s) => Math.abs(s / want - 1) <= 0.02)) return [];
+    return [
+      {
+        path: "output",
+        code: "OUTPUT_RATIO_MISMATCH",
+        severity: "warning",
+        message: `_definition.md declares ${format}, but this canvas delivers ${produced.join(", ")}. A ${format} placement would get the wrong shape: re-scaffold with that format, or fix the formats the creative declares.`
+      }
+    ];
+  });
+}
+async function outputRatioWarningsFor(canvas, canvasPath) {
+  const definition = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8").catch(() => null);
+  if (!definition) return [];
+  return outputRatioWarnings(definitionFormats(definition), await producedRatios(canvas));
+}
+
+export {
+  outputRatioWarningsFor
+};
+//# sourceMappingURL=chunk-QPZNLG7Y.js.map

package/dist/chunk-QSQGGONQ.js

@@ -0,0 +1,94 @@
+import {
+  ApiError
+} from "./chunk-PCKVSSVT.js";
+import {
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+
+// src/commands/landing/inspiration/shared.ts
+var INSPIRATION_HINTS = {
+  adapt: "Reference only. Re-express this in the client's BRAND.md palette, type and imagery register. Reusing a headline, subhead or CTA verbatim is a Tier 0 message-match failure (references/gotchas.md).",
+  structureNotCopy: "Take the structural decision, not the furniture: what the eye hits first, the grid ratio, what was deliberately left out. Your copy must come from the client's own offer."
+};
+function favoritesScopeHints(health, resultCount) {
+  if (!health) return [];
+  const hints = [];
+  if (health.savedPages === 0) {
+    hints.push(
+      "This company hasn't saved any reference pages yet, so there is no taste profile to search \u2014 an empty result here says nothing about the library. Search the whole shared library with --scope all, or save a page the client admires with `baker landing inspiration add <url>`."
+    );
+    return hints;
+  }
+  if (health.failedPages > 0) {
+    const retryable = health.failedExamples.filter((example) => example.retryable).map((example) => example.url);
+    const permanent = health.failedExamples.filter((example) => !example.retryable).map((example) => example.url);
+    hints.push(
+      `${health.failedPages} of this company's ${health.savedPages} saved pages could not be read, so they hold no sections \u2014 only ${health.usablePages} are usable, which is why this result is thin. Search the whole library with --scope all.`
+    );
+    if (retryable.length > 0) {
+      hints.push(
+        `Worth another go: ${retryable.join(", ")} \u2014 run \`baker landing inspiration add <url>\` on one of them to study it again.`
+      );
+    }
+    if (permanent.length > 0) {
+      hints.push(`Not worth retrying \u2014 these sites refuse automated readers: ${permanent.join(", ")}.`);
+    }
+  }
+  if (health.studyingPages > 0) {
+    hints.push(
+      `${health.studyingPages} saved ${health.studyingPages === 1 ? "page is" : "pages are"} still being studied and will be searchable in a few minutes. Carry on; do not wait on them.`
+    );
+  }
+  if (resultCount === 0 && health.failedPages === 0 && health.studyingPages === 0) {
+    hints.push(
+      `Nothing in this company's ${health.usablePages} readable saved pages matches. The saved set is healthy, so this is the query, not the library \u2014 loosen the filters or search everything with --scope all.`
+    );
+  }
+  return hints;
+}
+function fidelityHint(fidelity) {
+  if (fidelity == null) return null;
+  if (fidelity >= 0.9) return null;
+  if (fidelity >= 0.75) {
+    return `Reproduction fidelity ${fidelity.toFixed(2)} \u2014 the markup is close but not exact. Trust the screenshot over the code.`;
+  }
+  return `Reproduction fidelity ${fidelity.toFixed(2)} \u2014 this section is scroll- or JS-driven and the extracted markup does NOT render like the original. Use the screenshot and the notes; treat the code as a hint only.`;
+}
+var STALE_COPY_AFTER_MS = 30 * 24 * 60 * 60 * 1e3;
+function staleCopyHint(studiedAt, filedUrl, now = Date.now()) {
+  if (!studiedAt || now - studiedAt < STALE_COPY_AFTER_MS) return null;
+  const date = new Date(studiedAt).toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
+  return `This copy of the page was read on ${date}. If the user says the live page looks different, run: baker landing inspiration add ${filedUrl} --refresh`;
+}
+function reportError(error) {
+  if (error instanceof ApiError) {
+    writeJson({ ok: false, error: { code: error.code, message: error.message } });
+  } else {
+    writeJson({
+      ok: false,
+      error: { code: "UNKNOWN", message: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  process.exit(1);
+}
+function splitList(value) {
+  if (!value) return void 0;
+  const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function parseNumber(value) {
+  if (value === void 0 || value === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+
+export {
+  INSPIRATION_HINTS,
+  favoritesScopeHints,
+  fidelityHint,
+  staleCopyHint,
+  reportError,
+  splitList,
+  parseNumber
+};
+//# sourceMappingURL=chunk-QSQGGONQ.js.map

package/dist/chunk-QTXJHQSI.js

@@ -0,0 +1,60 @@
+import {
+  REF_PREFIX
+} from "./chunk-ERVDEVLC.js";
+
+// src/commands/canvas/node-preview.ts
+var MAX_PARAMS_PREVIEW_LENGTH = 4e3;
+var SPEC_KEYS = [
+  "model",
+  "aspect_ratio",
+  "image_size",
+  "resolution",
+  "duration",
+  "subject_type",
+  "font_size",
+  "expect",
+  "source",
+  "path",
+  "url"
+];
+var BODY_KEYS = ["prompt", "text", "subject_description"];
+function scalarField(params, key) {
+  const value = params[key];
+  if (typeof value === "number") return String(value);
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed && !trimmed.startsWith(REF_PREFIX) ? trimmed : void 0;
+}
+function compactJson(params) {
+  try {
+    const json = JSON.stringify(params);
+    return json && json !== "{}" ? json : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cap(text) {
+  return text.length > MAX_PARAMS_PREVIEW_LENGTH ? `${text.slice(0, MAX_PARAMS_PREVIEW_LENGTH - 1)}\u2026` : text;
+}
+function nodeParamsPreview(params, deps) {
+  const refsLine = deps && deps.length > 0 ? `refs: ${deps.join(", ")}` : void 0;
+  if (!params || typeof params !== "object") return refsLine;
+  const record = params;
+  const spec = [];
+  for (const key of SPEC_KEYS) {
+    const value = scalarField(record, key);
+    if (value !== void 0) spec.push(`${key}: ${value}`);
+  }
+  if (refsLine) spec.push(refsLine);
+  const body = BODY_KEYS.map((key) => scalarField(record, key)).find(Boolean);
+  const header = spec.join("\n");
+  const composed = header && body ? `${header}
+
+${body}` : header || body || compactJson(record);
+  return composed ? cap(composed) : void 0;
+}
+
+export {
+  nodeParamsPreview
+};
+//# sourceMappingURL=chunk-QTXJHQSI.js.map

package/dist/chunk-QW53AQYB.js

@@ -0,0 +1,274 @@
+import {
+  chatgptDraftOpInputSchema,
+  chatgptFailure
+} from "./chunk-LHCOWIGI.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-XNMSJP2X.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-PCKVSSVT.js";
+import {
+  requireChatId
+} from "./chunk-UW36KPPH.js";
+import {
+  registerSchema
+} from "./chunk-NU7JSWVA.js";
+
+// src/commands/ads/chatgpt/write-shared.ts
+import { defineCommand } from "citty";
+function fail(envelope) {
+  writeJsonEnvelope({ ...envelope });
+  process.exit(1);
+}
+function failWriteValidation(message) {
+  fail({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message,
+      fix: { action: "add_required_field", explanation: `${message}. Nothing was staged.` },
+      retryable: false
+    }
+  });
+}
+function writeFailure(err, reference) {
+  if (!(err instanceof ApiError) && err instanceof Error && err.message.includes("BAKER_CHAT_ID")) {
+    return {
+      ok: false,
+      error: {
+        code: "NO_CHAT",
+        message: err.message,
+        fix: {
+          action: "reject",
+          explanation: "ChatGPT Ads changes are staged on a chat and apply when it is published; run this from the chat."
+        },
+        retryable: false
+      }
+    };
+  }
+  return chatgptFailure(err, reference);
+}
+function decimalPlaces(value) {
+  const [mantissa, exponent] = String(value).trim().split(/e/i);
+  const written = (mantissa?.split(".")[1] ?? "").length;
+  return Math.max(0, written - (exponent ? Number(exponent) : 0));
+}
+function parseChatgptMoney(value) {
+  if (value === void 0 || value === "") {
+    return { ok: true, micros: void 0 };
+  }
+  const amount = Number(value);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return { ok: false, reason: "must be a positive amount, for example 12.50" };
+  }
+  if (decimalPlaces(value) > 6) {
+    return { ok: false, reason: "is finer than ChatGPT Ads can express" };
+  }
+  return { ok: true, micros: Math.round(amount * 1e6) };
+}
+function microsFromArg(value, flag) {
+  const parsed = parseChatgptMoney(value);
+  if (!parsed.ok) {
+    failWriteValidation(`${flag} ${parsed.reason}`);
+  }
+  return parsed.micros;
+}
+function csvArg(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return void 0;
+  }
+  const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function schemaArgs(args) {
+  return Object.fromEntries(
+    Object.entries(args).map(([name, arg]) => [
+      name,
+      {
+        type: arg.type === "positional" ? "string" : arg.type,
+        description: arg.description,
+        required: arg.required === true
+      }
+    ])
+  );
+}
+function lowerArg(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim().toLowerCase() : void 0;
+}
+function lowerCsvArg(value) {
+  return csvArg(value)?.map((part) => part.toLowerCase());
+}
+function compact(payload) {
+  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== void 0 && value !== ""));
+}
+function requireTarget(args, name) {
+  const value = args[name];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    failWriteValidation(`${name} is required`);
+  }
+  return value.trim();
+}
+function requireTargets(args, name) {
+  const ids = csvArg(args[name]);
+  if (!ids) {
+    failWriteValidation(`${name} is required \u2014 pass one or more ids, comma-separated`);
+  }
+  return ids;
+}
+function preflight(raw) {
+  const parsed = chatgptDraftOpInputSchema.safeParse(raw);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const fields = parsed.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message }));
+  const message = fields.map((field) => field.path ? `${field.path}: ${field.message}` : field.message).join("; ");
+  return fail({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message,
+      fix: {
+        action: "retry_with_modified_query",
+        explanation: "Fix the named fields and stage again. Nothing was staged \u2014 the draft is as it was before this call."
+      },
+      retryable: false
+    }
+  });
+}
+async function postStage(chatId, op) {
+  return await apiPost("/api/ads/chatgpt/draft/stage", { chatId, op });
+}
+async function stageChatgptOp(raw, reference, hintsFor) {
+  const op = preflight(raw);
+  try {
+    const staged = await postStage(requireChatId(), op);
+    const hints = hintsFor?.(staged) ?? [];
+    writeJsonEnvelope({ ok: true, data: staged, ...hints.length > 0 ? { hints } : {} });
+  } catch (err) {
+    fail(writeFailure(err, reference));
+  }
+}
+async function stageChatgptOps(raws, reference) {
+  if (raws.length === 1 && raws[0]) {
+    await stageChatgptOp(raws[0], reference);
+    return;
+  }
+  const ops = raws.map(preflight);
+  const staged = [];
+  try {
+    const chatId = requireChatId();
+    for (const op of ops) {
+      staged.push(await postStage(chatId, op));
+    }
+    writeJsonEnvelope({ ok: true, data: staged });
+  } catch (err) {
+    const failure = writeFailure(err, reference);
+    if (staged.length > 0) {
+      failure.error.message = `${failure.error.message} (already staged: ${staged.map((s) => s.summary).join("; ")})`;
+    }
+    fail(failure);
+  }
+}
+function clearableCsvArg(value) {
+  return typeof value === "string" && value.trim().toLowerCase() === "none" ? [] : csvArg(value);
+}
+function clearableArg(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return void 0;
+  }
+  return value.trim().toLowerCase() === "none" ? null : value.trim();
+}
+function cropArg(value, flag) {
+  const parts = csvArg(value);
+  if (!parts) {
+    return void 0;
+  }
+  const numbers = parts.map(Number);
+  const [x, y, width, height] = numbers;
+  if (numbers.length !== 4 || numbers.some(Number.isNaN) || x === void 0 || y === void 0 || width === void 0 || height === void 0) {
+    failWriteValidation(`${flag} takes four shares of the image, x,y,width,height \u2014 e.g. 0.1,0,0.8,0.8`);
+  }
+  return { x, y, width, height };
+}
+var STATUS_OF = {
+  pause: "paused",
+  resume: "active",
+  archive: "archived"
+};
+function statusOps(entity, ids, status) {
+  return ids.map((id) => ({ kind: `${entity}.update`, target: id, payload: { status } }));
+}
+var STATUS_NOUN = {
+  campaign: { command: "campaigns", plural: "campaigns", example: "cmpn_123,cmpn_456" },
+  adGroup: { command: "ad-groups", plural: "ad groups", example: "adgrp_123,adgrp_456" },
+  ad: { command: "ads", plural: "cards", example: "ad_123,ad_456" }
+};
+var STATUS_DOING = { pause: "pausing", resume: "resuming", archive: "archiving" };
+function statusCommand(entity, verb, reference) {
+  const noun = STATUS_NOUN[entity];
+  const args = {
+    ids: { type: "positional", description: `${noun.plural} ids, comma-separated`, required: true }
+  };
+  const forGood = verb === "archive" ? ` Archiving is for good: ChatGPT Ads cannot bring archived ${noun.plural} back, and their results stay in reports. Pause instead unless the user asked to archive.` : "";
+  registerSchema({
+    command: `ads.chatgpt.${noun.command}.${verb}`,
+    description: `Stage ${STATUS_DOING[verb]} one or more ChatGPT Ads ${noun.plural}. Pass every id in one call.${forGood}`,
+    args: schemaArgs(args)
+  });
+  return defineCommand({
+    meta: {
+      name: verb,
+      description: `Stage ${STATUS_DOING[verb]} ${noun.plural}.${forGood}
+
+Example:
+  baker ads chatgpt ${noun.command} ${verb} ${noun.example}`
+    },
+    args,
+    run: async ({ args: parsed }) => {
+      await stageChatgptOps(statusOps(entity, requireTargets(parsed, "ids"), STATUS_OF[verb]), reference);
+    }
+  });
+}
+function productFiltersArg(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return void 0;
+  }
+  if (value.trim().toLowerCase() === "none") {
+    return [];
+  }
+  return value.split(";").map((condition) => condition.trim()).filter(Boolean).map((condition) => {
+    const match = /^(\S+)\s+(\S+)\s+(.+)$/.exec(condition);
+    if (!match?.[1] || !match[2] || !match[3]) {
+      failWriteValidation(
+        `"${condition}" is not a product filter \u2014 write field operator values, e.g. price lte 5000`
+      );
+    }
+    return {
+      field: match[1],
+      operator: match[2].toLowerCase(),
+      values: match[3].split("|").map((part) => part.trim()).filter(Boolean)
+    };
+  });
+}
+
+export {
+  failWriteValidation,
+  microsFromArg,
+  csvArg,
+  schemaArgs,
+  lowerArg,
+  lowerCsvArg,
+  compact,
+  requireTarget,
+  requireTargets,
+  stageChatgptOp,
+  stageChatgptOps,
+  clearableCsvArg,
+  clearableArg,
+  cropArg,
+  statusCommand,
+  productFiltersArg
+};
+//# sourceMappingURL=chunk-QW53AQYB.js.map