@koda-sl/baker-cli 0.501.0 → 0.503.0

package/dist/chunk-YLQWWLCW.js

@@ -0,0 +1,219 @@
+import {
+  bareAccountId,
+  failWriteValidation,
+  numberFlag,
+  requireTarget,
+  stageOp,
+  stageOps
+} from "./chunk-S335LT4B.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/ads/meta/asset-writes.ts
+import { defineCommand } from "citty";
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads meta draft`.";
+var accountArg = { type: "string", description: "Meta ad account ID (act_123)" };
+var schemaId = (what) => ({ type: "positional", description: what, required: true });
+function command(input) {
+  registerSchema({
+    command: input.schema,
+    description: input.schemaDescription,
+    args: Object.fromEntries(
+      Object.entries(input.args).map(([key, arg]) => [
+        key,
+        { type: arg.type, description: arg.description, required: arg.required === true }
+      ])
+    )
+  });
+  return defineCommand({
+    meta: { name: input.name, description: `${input.description} ${STAGED_NOTE}` },
+    args: input.args,
+    run: async ({ args, rawArgs }) => {
+      await input.run(args, rawArgs);
+    }
+  });
+}
+var creativesDeleteCommand = command({
+  schema: "ads.meta.creatives.delete",
+  name: "delete",
+  description: "Stage deleting an ad creative. Meta deletes only a creative no ad runs \u2014 repoint or delete the ad first. Permanent.",
+  schemaDescription: "Stage deleting a Meta ad creative (status DELETED) \u2014 applied at publish, permanent. Meta refuses a creative an ad still runs.",
+  args: { id: { type: "positional", description: "Creative id", required: true }, "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "adCreative.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "creative"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var mediaDeleteCommand = command({
+  schema: "ads.meta.media.delete",
+  name: "delete",
+  description: "Stage taking an image out of the ad account's image library, by its hash (`baker ads meta images`), or one of its videos by id (`--video-id`, from `baker ads meta media`). Meta refuses an image a creative still uses.",
+  schemaDescription: "Stage deleting an image from a Meta ad account's image library by hash, or a video from its video library by id \u2014 applied at publish. Meta refuses an image a creative uses.",
+  args: {
+    "account-id": accountArg,
+    "image-hash": { type: "string", description: "The image's hash" },
+    "video-id": { type: "string", description: "Or a video of the ad account, by id" }
+  },
+  run: async (args) => {
+    const imageHash = typeof args["image-hash"] === "string" ? args["image-hash"] : void 0;
+    const videoId = typeof args["video-id"] === "string" ? args["video-id"] : void 0;
+    if (imageHash === void 0 === (videoId === void 0)) {
+      failWriteValidation("pass --image-hash (from `baker ads meta images`) or --video-id \u2014 one of them");
+    }
+    await stageOp({ kind: "media.delete", accountId: bareAccountId(args), payload: { imageHash, videoId } });
+  }
+});
+var customConversionsUpdateCommand = command({
+  schema: "ads.meta.custom-conversions.update",
+  name: "update",
+  description: "Stage renaming a Custom Conversion, its description or its value per conversion. Meta keeps a conversion's rule and event category for good \u2014 a conversion that counts something else is a new one.",
+  schemaDescription: "Stage a change to a Meta Custom Conversion: --name, --description, --value (value per conversion, account currency). The rule and event category cannot change (Meta accepts and ignores them).",
+  args: {
+    id: { type: "positional", description: "Custom conversion id", required: true },
+    "account-id": accountArg,
+    name: { type: "string", description: "New name" },
+    description: { type: "string", description: "New description" },
+    value: { type: "string", description: "Value of one conversion, in the account currency" }
+  },
+  run: async (args) => {
+    const payload = Object.fromEntries(
+      Object.entries({
+        name: args.name,
+        description: args.description,
+        default_conversion_value: numberFlag(args.value, "--value")
+      }).filter(([, value]) => value !== void 0)
+    );
+    await stageOp({
+      kind: "customConversion.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "custom conversion"),
+      payload
+    });
+  }
+});
+var customConversionsDeleteCommand = command({
+  schema: "ads.meta.custom-conversions.delete",
+  name: "delete",
+  description: "Stage deleting a Custom Conversion. Meta archives it: it stops counting and leaves the active list, and still uses one of the account's slots. Ad sets optimizing toward it stop finding conversions.",
+  schemaDescription: "Stage deleting (archiving) a Meta Custom Conversion \u2014 applied at publish. Not reversible; it keeps its slot in the account's cap.",
+  args: { id: schemaId("Custom conversion id"), "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "customConversion.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "custom conversion"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var labelsCreateCommand = command({
+  schema: "ads.meta.labels.create",
+  name: "create",
+  description: 'Stage a new ad label. File things under it with `labels attach <ref> --campaigns \u2026` in the same chat. Example: baker ads meta labels create --name "Q4 launch"',
+  schemaDescription: "Stage a new Meta ad label (created at publish). Returns a meta_temp_* ref `labels attach` takes.",
+  args: { "account-id": accountArg, name: { type: "string", description: "Label name" } },
+  run: async (args) => {
+    await stageOp({ kind: "adLabel.create", accountId: bareAccountId(args), payload: { name: args.name } });
+  }
+});
+var labelsRenameCommand = command({
+  schema: "ads.meta.labels.rename",
+  name: "rename",
+  description: "Stage renaming an ad label.",
+  schemaDescription: "Stage renaming a Meta ad label.",
+  args: { id: schemaId("Label id"), "account-id": accountArg, name: { type: "string", description: "New name" } },
+  run: async (args) => {
+    await stageOp({
+      kind: "adLabel.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "label"),
+      payload: { name: args.name }
+    });
+  }
+});
+var labelsDeleteCommand = command({
+  schema: "ads.meta.labels.delete",
+  name: "delete",
+  description: "Stage deleting an ad label. Everything filed under it keeps running, unlabelled.",
+  schemaDescription: "Stage deleting a Meta ad label \u2014 applied at publish; labelled objects keep running.",
+  args: { id: schemaId("Label id"), "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "adLabel.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "label"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var LABELLED = [
+  ["campaigns", "campaign.update"],
+  ["adsets", "adSet.update"],
+  ["ads", "ad.update"],
+  ["creatives", "adCreative.update"]
+];
+var targetArgs = {
+  campaigns: { type: "string", description: "Campaign ids (comma-separated or repeated)" },
+  adsets: { type: "string", description: "Ad set ids" },
+  ads: { type: "string", description: "Ad ids" },
+  creatives: {
+    type: "string",
+    description: "Creative ids (live ones \u2014 a creative created in this chat is labelled later)"
+  }
+};
+function idsOf(rawArgs, flag, parsed) {
+  return repeatedValues(rawArgs, flag, parsed).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+}
+async function stageLabelChange(verb, args, rawArgs) {
+  const accountId = bareAccountId(args);
+  const label = requireTarget(args, "label");
+  const targets = LABELLED.flatMap(([flag, kind]) => idsOf(rawArgs, flag, args[flag]).map((id) => ({ kind, id })));
+  if (targets.length === 0) {
+    failWriteValidation("name what to label: --campaigns, --adsets, --ads or --creatives");
+  }
+  await stageOps(
+    targets.map((target) => ({ kind: target.kind, accountId, target: target.id, payload: { [verb]: [label] } }))
+  );
+}
+var labelsAttachCommand = command({
+  schema: "ads.meta.labels.attach",
+  name: "attach",
+  description: "Stage filing campaigns, ad sets, ads or creatives under a label (a label id, or a meta_temp_* ref from `labels create`). Their other labels stay. Example: baker ads meta labels attach 120249 --campaigns 6123,6124",
+  schemaDescription: "Stage adding a Meta ad label to campaigns/ad sets/ads/creatives (--campaigns, --adsets, --ads, --creatives; comma-separated). One staged change per object; other labels kept.",
+  args: { id: schemaId("Label id or meta_temp_* ref"), "account-id": accountArg, ...targetArgs },
+  run: async (args, rawArgs) => {
+    await stageLabelChange("addLabels", args, rawArgs);
+  }
+});
+var labelsDetachCommand = command({
+  schema: "ads.meta.labels.detach",
+  name: "detach",
+  description: "Stage taking a label off campaigns, ad sets, ads or creatives. Their other labels stay.",
+  schemaDescription: "Stage removing a Meta ad label from campaigns/ad sets/ads/creatives (--campaigns, --adsets, --ads, --creatives). Other labels kept.",
+  args: { id: schemaId("Label id"), "account-id": accountArg, ...targetArgs },
+  run: async (args, rawArgs) => {
+    await stageLabelChange("removeLabels", args, rawArgs);
+  }
+});
+
+export {
+  command,
+  creativesDeleteCommand,
+  mediaDeleteCommand,
+  customConversionsUpdateCommand,
+  customConversionsDeleteCommand,
+  labelsCreateCommand,
+  labelsRenameCommand,
+  labelsDeleteCommand,
+  labelsAttachCommand,
+  labelsDetachCommand
+};
+//# sourceMappingURL=chunk-YLQWWLCW.js.map

package/dist/chunk-Z6I7MFJY.js

@@ -0,0 +1,97 @@
+import {
+  leadVersion,
+  writeSeriesMemberCanvas
+} from "./chunk-E5ESAJWJ.js";
+import {
+  claimNewCreativeInWorkspace,
+  creativeLimitRefusal
+} from "./chunk-XVFZDPEW.js";
+import {
+  definitionFieldsOf,
+  setDefinitionFields,
+  setSpecMessage
+} from "./chunk-YNYAT2TZ.js";
+import {
+  IDEAS_DIR
+} from "./chunk-SWN6OHXG.js";
+
+// src/commands/creatives/make-series.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { parseDocument } from "yaml";
+var LEAD_ONLY = ["idea", "message", "evidence", "angle", "persona", "awareness", "hypothesis", "series", "title"];
+function withoutFields(raw, keys) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return raw;
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return raw;
+  for (const key of keys) doc.delete(key);
+  return `---
+${doc.toString()}---${raw.slice(match[0].length)}`;
+}
+async function makeSeriesAd(root, idea, slug, lead, evidence, deps) {
+  if (slug === lead) {
+    return {
+      code: "series_of_itself",
+      message: `"${slug}" is the lead itself.`,
+      fix: "Give the new ad its own --slug."
+    };
+  }
+  const version = await leadVersion(root, lead);
+  if ("refused" in version) return version.refused;
+  const dir = path.join(root, "src", "creatives", slug);
+  const definitionPath = path.join(dir, "_definition.md");
+  const claim = await claimNewCreativeInWorkspace(path.join(root, "canvas"), slug, deps.chatId, definitionPath);
+  if (!claim.allowed) return creativeLimitRefusal(slug).error;
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, "prompt.json"), setSpecMessage(JSON.stringify(version.spec), idea.message), "utf8");
+  const leadDefinition = await readFile(path.join(root, "src", "creatives", lead, "_definition.md"), "utf8").catch(
+    () => "---\nkind: static\n---\n"
+  );
+  const definition = setDefinitionFields(withoutFields(leadDefinition, LEAD_ONLY), {
+    title: idea.message.slice(0, 120),
+    series: lead,
+    status: "draft",
+    ...definitionFieldsOf(idea, evidence)
+  });
+  await writeFile(definitionPath, definition, "utf8");
+  const made = await writeSeriesMemberCanvas(root, slug, { leadWords: true });
+  if (made === null || "refused" in made) {
+    return made?.refused ?? { code: "series_not_made", message: `"${slug}" could not be made in the series of "${lead}".` };
+  }
+  if (idea.status === "idea") {
+    const ideaPath = path.join(root, IDEAS_DIR, `${idea.id}.md`);
+    const raw = await readFile(ideaPath, "utf8").catch(() => null);
+    if (raw !== null) await writeFile(ideaPath, setDefinitionFields(raw, { status: "built" }), "utf8");
+  }
+  await deps.sync(dir);
+  return { slug, lead, leadRunId: version.lead.runId, canvasPath: made.canvasPath };
+}
+function seriesMadeEnvelope(made, idea) {
+  const lead = made.leadPlatforms ?? [];
+  const elsewhere = (idea.platforms ?? []).some((p) => !lead.includes(p));
+  return {
+    ok: true,
+    data: {
+      creative: made.slug,
+      idea: idea.id,
+      message: idea.message,
+      series: made.lead,
+      canvas_path: made.canvasPath
+    },
+    hints: [
+      `Write this ad's words in src/creatives/${made.slug}/prompt.json \`copy\`: one line for each of the lead's, in the same roles and about as long, saying this idea's message. Change nothing else: the picture, layout and colours are the lead's (${made.lead}), and every word you write replaces the lead's line in its place.`,
+      `When every ad of the series has its words: baker canvas run --series ${made.lead} (renders them all at once, each reviewed and corrected on its own).`,
+      ...elsewhere && lead.length > 0 ? [
+        `A series ad runs where its lead runs (${lead.join(", ")}), in its sizes; the idea names ${idea.platforms?.join(", ")}. To run it there, make it on its own: baker creatives make ${idea.id} --platforms ${idea.platforms?.join(",")}.`
+      ] : []
+    ]
+  };
+}
+
+export {
+  withoutFields,
+  makeSeriesAd,
+  seriesMadeEnvelope
+};
+//# sourceMappingURL=chunk-Z6I7MFJY.js.map

package/dist/chunk-ZNRGH4NS.js

@@ -0,0 +1,150 @@
+import {
+  GEO_TARGET_COUNTRIES,
+  LANGUAGE_CONSTANTS
+} from "./chunk-2TOIY2WN.js";
+
+// src/geo-context.ts
+function toOptions(names) {
+  return Object.entries(names).map(([id, name]) => ({ id, name })).sort((a, b) => a.name.localeCompare(b.name));
+}
+var GOOGLE_ADS_LOCATIONS = toOptions(GEO_TARGET_COUNTRIES);
+var GOOGLE_ADS_LANGUAGES = toOptions(LANGUAGE_CONSTANTS);
+var DATAFORSEO_LOCATIONS = [
+  { code: "us", name: "United States" },
+  { code: "uk", name: "United Kingdom" },
+  { code: "gb", name: "United Kingdom" },
+  { code: "ca", name: "Canada" },
+  { code: "au", name: "Australia" },
+  { code: "de", name: "Germany" },
+  { code: "fr", name: "France" },
+  { code: "es", name: "Spain" },
+  { code: "it", name: "Italy" },
+  { code: "br", name: "Brazil" },
+  { code: "mx", name: "Mexico" },
+  { code: "nl", name: "Netherlands" },
+  { code: "be", name: "Belgium" },
+  { code: "at", name: "Austria" },
+  { code: "ch", name: "Switzerland" },
+  { code: "pt", name: "Portugal" },
+  { code: "se", name: "Sweden" },
+  { code: "no", name: "Norway" },
+  { code: "dk", name: "Denmark" },
+  { code: "fi", name: "Finland" },
+  { code: "ie", name: "Ireland" },
+  { code: "nz", name: "New Zealand" },
+  { code: "in", name: "India" },
+  { code: "jp", name: "Japan" },
+  { code: "kr", name: "South Korea" },
+  { code: "sg", name: "Singapore" },
+  { code: "ar", name: "Argentina" },
+  { code: "cl", name: "Chile" },
+  { code: "co", name: "Colombia" },
+  { code: "pe", name: "Peru" },
+  { code: "pl", name: "Poland" },
+  { code: "cz", name: "Czech Republic" },
+  { code: "ro", name: "Romania" },
+  { code: "hu", name: "Hungary" },
+  { code: "za", name: "South Africa" },
+  { code: "il", name: "Israel" },
+  { code: "ae", name: "United Arab Emirates" },
+  { code: "sa", name: "Saudi Arabia" },
+  { code: "tr", name: "Turkey" },
+  { code: "ph", name: "Philippines" },
+  { code: "th", name: "Thailand" },
+  { code: "my", name: "Malaysia" },
+  { code: "id", name: "Indonesia" },
+  { code: "vn", name: "Vietnam" },
+  { code: "tw", name: "Taiwan" },
+  { code: "hk", name: "Hong Kong" }
+];
+var DATAFORSEO_LANGUAGES = [
+  { code: "en", name: "English" },
+  { code: "es", name: "Spanish" },
+  { code: "fr", name: "French" },
+  { code: "de", name: "German" },
+  { code: "it", name: "Italian" },
+  { code: "pt", name: "Portuguese" },
+  { code: "nl", name: "Dutch" },
+  { code: "ja", name: "Japanese" },
+  { code: "ko", name: "Korean" },
+  { code: "zh", name: "Chinese" },
+  { code: "ar", name: "Arabic" },
+  { code: "ru", name: "Russian" },
+  { code: "pl", name: "Polish" },
+  { code: "tr", name: "Turkish" },
+  { code: "sv", name: "Swedish" },
+  { code: "no", name: "Norwegian" },
+  { code: "da", name: "Danish" },
+  { code: "fi", name: "Finnish" }
+];
+function toRecord(list) {
+  const map = {};
+  for (const item of list) {
+    const key = item.id ?? item.code;
+    if (key) map[key] = item.name;
+  }
+  return map;
+}
+var researchLocationMap = toRecord(DATAFORSEO_LOCATIONS);
+var researchLanguageMap = toRecord(DATAFORSEO_LANGUAGES);
+function buildAdsQueryContext(locationArg, languageArg) {
+  const locationId = locationArg ?? "2840";
+  const languageId = languageArg ?? "1000";
+  const locationIsDefault = !locationArg;
+  const languageIsDefault = !languageArg;
+  const locationName = GEO_TARGET_COUNTRIES[locationId] ?? `ID ${locationId}`;
+  const languageName = LANGUAGE_CONSTANTS[languageId] ?? `ID ${languageId}`;
+  const ctx = {
+    location: `${locationName} (${locationId})`,
+    language: `${languageName} (${languageId})`,
+    location_is_default: locationIsDefault,
+    language_is_default: languageIsDefault
+  };
+  if (locationIsDefault || languageIsDefault) {
+    const parts = [];
+    if (locationIsDefault) parts.push("--location");
+    if (languageIsDefault) parts.push("--language");
+    ctx.defaults_warning = `Location and/or language were not specified \u2014 using defaults. Results are for ${locationName} in ${languageName}. Pass ${parts.join(" and ")} to target a different market.`;
+  }
+  return ctx;
+}
+function buildResearchQueryContext(locationArg, languageArg, options) {
+  const skipLocation = options?.skipLocation ?? false;
+  const locationCode = locationArg ?? "us";
+  const languageCode = languageArg ?? "en";
+  const locationIsDefault = !locationArg && !skipLocation;
+  const languageIsDefault = !languageArg;
+  const locationName = researchLocationMap[locationCode.toLowerCase()] ?? `code ${locationCode}`;
+  const languageName = researchLanguageMap[languageCode.toLowerCase()] ?? `code ${languageCode}`;
+  const ctx = {
+    location: skipLocation ? "N/A" : `${locationName} (${locationCode})`,
+    language: `${languageName} (${languageCode})`,
+    location_is_default: locationIsDefault,
+    language_is_default: languageIsDefault
+  };
+  const defaultParts = [];
+  if (locationIsDefault) defaultParts.push("--location");
+  if (languageIsDefault) defaultParts.push("--language");
+  if (defaultParts.length > 0) {
+    const market = skipLocation ? `${languageName}` : `${locationName} in ${languageName}`;
+    ctx.defaults_warning = `Location and/or language were not specified \u2014 using defaults. Results are for ${market}. Pass ${defaultParts.join(" and ")} to target a different market.`;
+  }
+  return ctx;
+}
+function warnDefaults(ctx) {
+  if (ctx.defaults_warning) {
+    process.stderr.write(`
+[WARNING] ${ctx.defaults_warning}
+
+`);
+  }
+}
+
+export {
+  GOOGLE_ADS_LOCATIONS,
+  GOOGLE_ADS_LANGUAGES,
+  buildAdsQueryContext,
+  buildResearchQueryContext,
+  warnDefaults
+};
+//# sourceMappingURL=chunk-ZNRGH4NS.js.map

package/dist/chunk-ZT3LROOY.js

@@ -0,0 +1,19 @@
+import {
+  latestVersion
+} from "./chunk-XW35UMDI.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-EJGAJHLB.js";
+
+// src/commands/creatives/version-of.ts
+import path from "path";
+async function versionOf(slug, run) {
+  if (typeof run === "string" && run.trim()) return run.trim();
+  const canvas = path.join("src", "creatives", slug, `${slug}.canvas.json`);
+  return await latestVersion(canvasOutputsRoot(canvas), slug) ?? void 0;
+}
+
+export {
+  versionOf
+};
+//# sourceMappingURL=chunk-ZT3LROOY.js.map