@koda-sl/baker-cli 0.502.0 → 0.504.0-dev.239e52d65

package/dist/chunk-IDK7Z5UJ.js

@@ -0,0 +1,274 @@
+import {
+  chatgptDraftOpInputSchema,
+  chatgptFailure
+} from "./chunk-APMDFIM6.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  requireChatId
+} from "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.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,
+        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-IDK7Z5UJ.js.map

package/dist/chunk-IQASMSVP.js

@@ -0,0 +1,285 @@
+import {
+  IDEA_VIDEO_FORMATS,
+  figuresIn,
+  unsourcedClaims
+} from "./chunk-EFPIK64C.js";
+import {
+  AD_SPEC_SCHEMA,
+  unfitReasons
+} from "./chunk-ELXYZUHU.js";
+import {
+  proofStrength
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/creatives/make-model.ts
+import { parse, parseDocument, Scalar, visit } from "yaml";
+var REFERENCE_CANDIDATES = 6;
+function isVideoIdea(idea) {
+  return IDEA_VIDEO_FORMATS.includes(idea.format ?? "");
+}
+var BY_TEMPERATURE = {
+  cold: { audienceTemperature: "0_cold", excludeBrandReliant: true },
+  warm: { audienceTemperature: "1_warm_engaged,2_hot_visited", excludeBrandReliant: true },
+  hot: { audienceTemperature: "3_customer" }
+};
+function referenceSearchFor(idea, temperature, where = {}) {
+  return {
+    query: where.category || idea.message,
+    scope: "followed-first",
+    platform: "meta",
+    format: "static",
+    formatPattern: idea.format,
+    awareness: idea.awareness,
+    ...BY_TEMPERATURE[temperature],
+    ...where.country ? { country: where.country } : {},
+    maxPerAdvertiser: 1,
+    limit: REFERENCE_CANDIDATES,
+    diverse: true
+  };
+}
+function referenceSearchesFor(idea, temperature, where = {}) {
+  const strict = referenceSearchFor(idea, temperature, where);
+  const { awareness: _awareness, ...anyStage } = strict;
+  const { audienceTemperature: _temperature, excludeBrandReliant: _reliant, ...viewerAny } = anyStage;
+  const anyViewer = { ...viewerAny, scope: "all" };
+  const { formatPattern: _pattern, ...anyContainer } = anyViewer;
+  const { country: _country, ...anywhere } = anyViewer;
+  const { country: _anyCountry, ...anyContainerAnywhere } = anyContainer;
+  const { query: _query, ...winners } = anyStage;
+  const { query: _anyQuery, country: _winnersCountry, ...winnersAnywhere } = anyViewer;
+  const inMarket = (steps) => where.country ? steps : [];
+  const shows = idea.shows?.trim();
+  const { formatPattern: _shownPattern, ...anyCategory } = { ...anyStage, scope: "all" };
+  const { country: _shownCountry, ...anyCategoryAnywhere } = anyCategory;
+  const { country: _viewerCountry, ...anyViewerAnywhere } = anyViewer;
+  const { formatPattern: _anyPattern, ...shownAnyViewer } = anyViewerAnywhere;
+  const kinds = (where.shows ?? []).flatMap((q) => q.trim() ? [{ ...anyCategoryAnywhere, query: q.trim() }] : []);
+  const shown = shows ? [
+    ...inMarket([{ ...anyCategory, query: shows }]),
+    ...kinds,
+    { ...anyCategoryAnywhere, query: shows },
+    { ...shownAnyViewer, query: shows },
+    ...idea.format ? [{ ...anyViewerAnywhere, query: shows }] : []
+  ] : [];
+  const anyAd = (query) => query?.trim() ? [...inMarket([{ ...anyContainer, query: query.trim() }]), { ...anyContainerAnywhere, query: query.trim() }] : [];
+  if (shows) {
+    return [
+      ...shown,
+      ...where.category ? [anyContainerAnywhere] : [],
+      ...where.audience?.trim() ? [{ ...anyContainerAnywhere, query: where.audience.trim() }] : [],
+      { ...winnersAnywhere, sort: "winner" }
+    ];
+  }
+  return [
+    ...where.country ? [strict, anyStage, anyContainer] : [strict, anyStage],
+    anywhere,
+    anyContainerAnywhere,
+    ...anyAd(where.audience),
+    ...(where.wider ?? []).flatMap((q) => q.trim() ? [{ ...anyContainerAnywhere, query: q.trim() }] : []),
+    ...anyAd(where.industry),
+    ...where.category ? [{ ...anyContainerAnywhere, query: idea.message }] : [],
+    ...inMarket([{ ...winners, sort: "winner" }]),
+    { ...winnersAnywhere, sort: "winner" }
+  ];
+}
+function referenceWhereOf(brief, fallback) {
+  if (!brief) return fallback;
+  const country = brief.country === null ? void 0 : brief.country ?? fallback.country;
+  const audience = brief.audience ?? fallback.audience;
+  return {
+    ...country ? { country } : {},
+    category: brief.category,
+    ...brief.industry ? { industry: brief.industry } : {},
+    ...audience ? { audience } : {},
+    ...brief.wider.length ? { wider: brief.wider } : {},
+    ...brief.shows?.length ? { shows: brief.shows } : {}
+  };
+}
+function rankedForOf(brief, where, bet) {
+  return {
+    category: brief?.category ?? where.category ?? bet.message,
+    ...brief?.industry ? { industry: brief.industry } : {},
+    ...brief?.buyer ? { buyer: brief.buyer } : {},
+    ...brief?.humour ? { humour: brief.humour } : {},
+    ...brief?.memes ? { memes: brief.memes } : {},
+    ...brief?.memesWhy ? { memesWhy: brief.memesWhy } : {},
+    ...brief?.avoid.length ? { avoid: brief.avoid } : {},
+    message: bet.message,
+    who: bet.who,
+    ...bet.shows ? { shows: bet.shows } : {}
+  };
+}
+var brandKey = (name) => name.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+function isOwnBrand(advertiser, brands) {
+  const page = brandKey(advertiser ?? "");
+  return page !== "" && brands.some((b) => brandKey(b).length >= 3 && page.includes(brandKey(b)));
+}
+function pooledCandidates(searches, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const pooled = [];
+  for (const candidate of searches.flat()) {
+    const brand = candidate.advertiser_id ? `brand:${candidate.advertiser_id}` : null;
+    if (!candidate.ad_id || seen.has(candidate.ad_id) || brand && seen.has(brand)) continue;
+    seen.add(candidate.ad_id);
+    if (brand) seen.add(brand);
+    pooled.push(candidate);
+  }
+  const proven = (c) => proofStrength(c.winner_score) !== "little";
+  return [...pooled.filter(proven), ...pooled.filter((c) => !proven(c))].slice(0, limit);
+}
+function freshReferencesFirst(candidates, taken) {
+  return [
+    ...candidates.filter((c) => !isTakenReference(c, taken)),
+    ...candidates.filter((c) => isTakenReference(c, taken))
+  ];
+}
+function isTakenReference(c, taken) {
+  return c.ad_id != null && taken.adIds.has(c.ad_id) || c.advertiser_id != null && taken.advertiserIds.has(c.advertiser_id);
+}
+function fitsIdea(fit) {
+  return fit.verdict !== "reject" && missingElements(fit).length === 0 && fit.our_viewer?.stops !== "no";
+}
+function missingElements(fit) {
+  return fit.load_bearing.filter((l) => l.have === "missing" && !l.ours?.trim()).map((l) => l.element);
+}
+function whyUnfit(fit) {
+  const reasons = unfitReasons(fit);
+  if (reasons.length > 0) return reasons.join("; ");
+  if (fit.our_viewer?.stops === "no") {
+    return `our viewer would not stop for it${fit.our_viewer.why ? `: ${fit.our_viewer.why}` : ""}`;
+  }
+  return fit.transfer_note?.trim() || "the check found it does not carry this ad";
+}
+function definitionFieldsOf(idea, evidence) {
+  return {
+    idea: idea.id,
+    message: idea.message,
+    ...evidence !== "explore" ? { evidence } : {},
+    angle: idea.angle,
+    persona: idea.who,
+    awareness: idea.awareness,
+    hypothesis: idea.why
+  };
+}
+var FRONTMATTER = /^---\r?\n([\s\S]*?\r?\n)?---/;
+function readsAsText11(text) {
+  try {
+    return parse(text, { version: "1.1" }) === text;
+  } catch {
+    return false;
+  }
+}
+function setDefinitionFields(raw, fields) {
+  const match = raw.match(FRONTMATTER);
+  if (!match) return raw;
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return raw;
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) continue;
+    const node = doc.createNode(value);
+    visit(node, {
+      Scalar(_, scalar) {
+        if (typeof scalar.value === "string" && !readsAsText11(scalar.value)) {
+          scalar.type = Scalar.QUOTE_DOUBLE;
+        }
+      }
+    });
+    doc.set(key, node);
+  }
+  return `---
+${doc.toString()}---${raw.slice(match[0].length)}`;
+}
+function setSpecMessage(specJson, message) {
+  const spec = JSON.parse(specJson);
+  return `${JSON.stringify({ ...spec, message }, null, 2)}
+`;
+}
+function setSpecViewer(specJson, idea, personas) {
+  const spec = JSON.parse(specJson);
+  const viewer = spec.viewer ?? {};
+  return `${JSON.stringify({ ...spec, viewer: { ...viewer, who: personaWho(idea, personas) } }, null, 2)}
+`;
+}
+function personaWho(idea, personas) {
+  const persona = personas.find((p) => p.slug === idea.who);
+  if (persona?.title) return `${persona.title}${persona.segment ? ` (${persona.segment})` : ""}`;
+  return persona?.segment ?? idea.who.replace(/[-_]/g, " ");
+}
+var AUDIENCE_QUERY_WORDS = 9;
+function audienceQuery(idea, personas) {
+  return personaWho(idea, personas).replace(/\(/g, " ").replace(/\)/g, "").split(/\s+/).filter(Boolean).slice(0, AUDIENCE_QUERY_WORDS).join(" ").replace(/[\s,;:.–—-]+$/, "");
+}
+function fitBetOf(idea, personas, insights, market) {
+  const quotes = insights.filter((i) => idea.evidence.includes(i.id)).map((i) => i.quote);
+  return {
+    who: personaWho(idea, personas),
+    message: idea.message,
+    awareness: idea.awareness,
+    angle: idea.angle,
+    ...idea.shows ? { shows: idea.shows } : {},
+    ...quotes.length > 0 ? { quotes } : {},
+    ...market ? { market } : {}
+  };
+}
+function withFitConcept(specJson, seeded) {
+  const spec = JSON.parse(specJson);
+  const held = spec.concept;
+  if (held?.reference_ad_id) return specJson;
+  return `${JSON.stringify({ ...spec, ...seeded }, null, 2)}
+`;
+}
+function unsourcedCopyLines(specJson, corpus) {
+  const spec = JSON.parse(specJson);
+  const figures = figuresIn(corpus);
+  const lines = Array.isArray(spec.copy) ? spec.copy : [];
+  return lines.flatMap((line) => {
+    const text = typeof line === "object" && line !== null ? line.text : void 0;
+    return typeof text === "string" && unsourcedClaims(text, figures).length > 0 ? [text] : [];
+  });
+}
+var PHOTO_FORMATS = /photo|lifestyle|before_after|ugc|product|selfie|street/;
+function ideaSpec(idea, who) {
+  const container = idea.format ? `, as a ${idea.format.replace(/_/g, " ")}` : "";
+  const shows = idea.shows ? ` (${idea.shows})` : "";
+  return {
+    schema: AD_SPEC_SCHEMA,
+    viewer: { who },
+    message: idea.message,
+    copy: [{ text: "[TODO: the headline, in the customer's words]", lettering: "designed", role: "headline" }],
+    scene: {
+      description: `[TODO: what the viewer sees first${shows}${container}, that shows: ${idea.message}]`,
+      look: PHOTO_FORMATS.test(idea.format ?? idea.shows ?? "") ? "photo" : "designed"
+    },
+    colors: [],
+    references: [],
+    logo: true,
+    third_party_brands: [],
+    scene_text: [],
+    mechanism: []
+  };
+}
+
+export {
+  isVideoIdea,
+  referenceSearchesFor,
+  referenceWhereOf,
+  rankedForOf,
+  isOwnBrand,
+  pooledCandidates,
+  freshReferencesFirst,
+  isTakenReference,
+  fitsIdea,
+  missingElements,
+  whyUnfit,
+  definitionFieldsOf,
+  setDefinitionFields,
+  setSpecMessage,
+  setSpecViewer,
+  personaWho,
+  audienceQuery,
+  fitBetOf,
+  withFitConcept,
+  unsourcedCopyLines,
+  ideaSpec
+};
+//# sourceMappingURL=chunk-IQASMSVP.js.map