@koda-sl/baker-cli 0.467.0 → 0.469.0-dev.42f26270e

package/dist/chunk-SMUBQFWI.js

@@ -0,0 +1,160 @@
+import {
+  IDEA_VIDEO_FORMATS,
+  figuresIn,
+  unsourcedClaims
+} from "./chunk-QVBU3AV5.js";
+import {
+  AD_SPEC_SCHEMA
+} from "./chunk-AAEPZ3RE.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, excludeAdvertiser) {
+  return {
+    query: idea.message,
+    scope: "followed-first",
+    platform: "meta",
+    format: "static",
+    formatPattern: idea.format,
+    awareness: idea.awareness,
+    ...BY_TEMPERATURE[temperature],
+    ...excludeAdvertiser ? { excludeAdvertiser } : {},
+    maxPerAdvertiser: 1,
+    limit: REFERENCE_CANDIDATES,
+    diverse: true
+  };
+}
+function referenceSearchesFor(idea, temperature, excludeAdvertiser) {
+  const strict = referenceSearchFor(idea, temperature, excludeAdvertiser);
+  const { awareness: _awareness, ...anyStage } = strict;
+  const { audienceTemperature: _temperature, excludeBrandReliant: _reliant, ...anyViewer } = anyStage;
+  const { query: _query, ...winners } = anyStage;
+  const { query: _anyQuery, ...anyWinners } = anyViewer;
+  return [
+    strict,
+    anyStage,
+    { ...anyViewer, scope: "all" },
+    { ...winners, sort: "winner" },
+    { ...anyWinners, scope: "all", sort: "winner" }
+  ];
+}
+function pooledCandidates(searches, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const pooled = [];
+  for (const candidate of searches.flat()) {
+    if (!candidate.ad_id || seen.has(candidate.ad_id)) continue;
+    seen.add(candidate.ad_id);
+    pooled.push(candidate);
+  }
+  return pooled.slice(0, limit);
+}
+function fitsIdea(fit) {
+  return fit.verdict !== "reject" && missingElements(fit).length === 0;
+}
+function missingElements(fit) {
+  return fit.load_bearing.filter((l) => l.have === "missing" && !l.ours?.trim()).map((l) => l.element);
+}
+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 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.replace(/_/g, " ");
+  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, as a ${container}, that shows: ${idea.message}]`,
+      look: PHOTO_FORMATS.test(idea.format) ? "photo" : "designed"
+    },
+    colors: [],
+    references: [],
+    logo: false,
+    third_party_brands: [],
+    scene_text: [],
+    mechanism: []
+  };
+}
+
+export {
+  isVideoIdea,
+  referenceSearchesFor,
+  pooledCandidates,
+  fitsIdea,
+  missingElements,
+  definitionFieldsOf,
+  setDefinitionFields,
+  setSpecMessage,
+  withFitConcept,
+  unsourcedCopyLines,
+  ideaSpec
+};
+//# sourceMappingURL=chunk-SMUBQFWI.js.map

package/dist/chunk-SQ7DRYCC.js

@@ -0,0 +1,150 @@
+import {
+  GEO_TARGET_COUNTRIES,
+  LANGUAGE_CONSTANTS
+} from "./chunk-I2DNBEV6.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-SQ7DRYCC.js.map

package/dist/chunk-SQWQDLAJ.js

@@ -0,0 +1,169 @@
+import {
+  parseXApiError
+} from "./chunk-M6UNISGO.js";
+import {
+  resolveXAccountId
+} from "./chunk-R3AL2MDF.js";
+import {
+  writeAdsJson,
+  writeJsonEnvelope
+} from "./chunk-7FNZ5BR6.js";
+import {
+  X_DRAFT_BATCH_MAX,
+  xDraftOpInputSchema
+} from "./chunk-RPJYEJDQ.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-L3EIZ7OV.js";
+import {
+  requireChatId
+} from "./chunk-MSCFMNJP.js";
+
+// src/commands/ads/x/write-shared.ts
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function failPreflight(fields) {
+  writeJsonEnvelope({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: fields.map((f) => f.path ? `${f.path}: ${f.message}` : f.message).join("; "),
+      fields,
+      fix: {
+        action: "reject",
+        explanation: "Fix the named fields and stage again. Nothing was staged \u2014 the draft is exactly as it was before this call."
+      }
+    }
+  });
+  process.exit(1);
+}
+function handleXWriteError(err, accountId) {
+  if (err instanceof ApiError) {
+    writeAdsJson(parseXApiError(err.message, accountId));
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+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 parseXMoney(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 X can express \u2014 it takes whole micros" };
+  }
+  return { ok: true, micros: Math.round(amount * 1e6) };
+}
+function microsFromArg(value, flag) {
+  const parsed = parseXMoney(value);
+  if (!parsed.ok) {
+    failWriteValidation(`${flag} ${parsed.reason}`);
+  }
+  return parsed.micros;
+}
+function csvArg(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function compact(payload) {
+  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== void 0));
+}
+function batchNudge(data) {
+  const count = data?.sameKindStaged;
+  if (!count) {
+    return [];
+  }
+  return [
+    `${count} other change${count === 1 ? "" : "s"} of this kind and payload ${count === 1 ? "is" : "are"} already staged \u2014 pass every id to one call (\`--ids a,b,c\`) instead of one call each.`
+  ];
+}
+async function stageXOp(raw, hints) {
+  const preflight = xDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    failPreflight(preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message })));
+  }
+  const accountId = String(raw.accountId ?? "\u2014");
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/x/draft/stage", { chatId, op: preflight.data });
+    const allHints = [...batchNudge(response.data), ...hints ?? []];
+    writeJsonEnvelope(allHints.length > 0 ? { ...response, hints: allHints } : response);
+  } catch (err) {
+    handleXWriteError(err, accountId);
+  }
+}
+async function stageXOps(rawOps, hints) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageXOp(rawOps[0], hints);
+    return;
+  }
+  if (rawOps.length > X_DRAFT_BATCH_MAX) {
+    failWriteValidation(`at most ${X_DRAFT_BATCH_MAX} changes can be staged in one call`);
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = xDraftOpInputSchema.safeParse(raw);
+    if (!preflight.success) {
+      failPreflight(
+        preflight.error.issues.map((issue) => ({
+          path: `ops[${index}]${issue.path.length > 0 ? `.${issue.path.join(".")}` : ""}`,
+          message: issue.message
+        }))
+      );
+    }
+    ops.push(preflight.data);
+  }
+  const accountId = String(rawOps[0]?.accountId ?? "\u2014");
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/x/draft/stage-batch", { chatId, ops });
+    writeJsonEnvelope(hints && hints.length > 0 ? { ...response, hints } : response);
+  } catch (err) {
+    handleXWriteError(err, accountId);
+  }
+}
+async function stageAccountId(args) {
+  return await resolveXAccountId(args);
+}
+function requireTarget(args, name) {
+  const value = args[name];
+  if (typeof value !== "string" || value.length === 0) {
+    failWriteValidation(`${name} is required`);
+  }
+  return value;
+}
+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;
+}
+
+export {
+  failWriteValidation,
+  microsFromArg,
+  csvArg,
+  compact,
+  stageXOp,
+  stageXOps,
+  stageAccountId,
+  requireTarget,
+  requireTargets
+};
+//# sourceMappingURL=chunk-SQWQDLAJ.js.map

package/dist/chunk-SWEMPOSU.js

@@ -0,0 +1,103 @@
+import {
+  SITE_COLLECTION_MODES,
+  SITE_CONSENT_MODES,
+  SITE_HOME_MODES
+} from "./chunk-RPJYEJDQ.js";
+import {
+  ApiError
+} from "./chunk-L3EIZ7OV.js";
+import {
+  writeJson
+} from "./chunk-KCA5CDCU.js";
+
+// src/commands/site/setArgs.ts
+var SiteArgsError = class extends Error {
+};
+function oneOf(flag, value, allowed) {
+  if (!allowed.includes(value)) {
+    throw new SiteArgsError(`--${flag} must be one of: ${allowed.join(", ")}`);
+  }
+  return value;
+}
+function onOff(flag, value) {
+  if (value === "on" || value === "true") return true;
+  if (value === "off" || value === "false") return false;
+  throw new SiteArgsError(`--${flag} must be on or off`);
+}
+function parseProfile(raw, readFile) {
+  const text = raw.startsWith("@") ? readFile(raw.slice(1)) : raw;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new SiteArgsError("--export-profile must be JSON, or @path to a JSON file");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new SiteArgsError("--export-profile must be a JSON object");
+  }
+  return parsed;
+}
+function parseSetArgs(args, readFile) {
+  const inputs = [];
+  if (args.consent !== void 0) {
+    inputs.push({ setting: "consent", mode: oneOf("consent", args.consent, SITE_CONSENT_MODES) });
+  }
+  if (args.collection !== void 0) {
+    const mode = oneOf("collection", args.collection, SITE_COLLECTION_MODES);
+    inputs.push({
+      setting: "analyticsCollection",
+      mode,
+      ...args.payloads === void 0 ? {} : { payloads: onOff("payloads", args.payloads) }
+    });
+  } else if (args.payloads !== void 0) {
+    throw new SiteArgsError("--payloads goes with --collection, e.g. --collection full --payloads off");
+  }
+  if (args.indexing !== void 0) {
+    inputs.push({ setting: "indexing", enabled: onOff("indexing", args.indexing) });
+  }
+  if (args.home !== void 0) {
+    const slug = args.home.trim().replace(/^\/+|\/+$/g, "");
+    inputs.push(
+      slug === "none" || slug === "" ? { setting: "homePage", override: null } : {
+        setting: "homePage",
+        override: { mode: oneOf("home-mode", args["home-mode"] ?? "rewrite", SITE_HOME_MODES), slug }
+      }
+    );
+  } else if (args["home-mode"] !== void 0) {
+    throw new SiteArgsError("--home-mode goes with --home <landing slug>");
+  }
+  if (args.timezone !== void 0) {
+    inputs.push({ setting: "timezone", timezone: args.timezone });
+  }
+  if (args["export-profile"] !== void 0) {
+    inputs.push({ setting: "exportProfile", profile: parseProfile(args["export-profile"], readFile) });
+  }
+  if (inputs.length === 0) {
+    throw new SiteArgsError(
+      "Nothing to stage. Pass at least one of --consent, --collection, --indexing, --home, --timezone, --export-profile."
+    );
+  }
+  return inputs;
+}
+
+// src/commands/site/shared.ts
+function failSite(err) {
+  if (err instanceof SiteArgsError) {
+    writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: err.message } });
+  } else if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+  } else {
+    writeJson({
+      ok: false,
+      error: { code: "INTERNAL_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+    });
+  }
+  process.exit(1);
+}
+
+export {
+  SiteArgsError,
+  parseSetArgs,
+  failSite
+};
+//# sourceMappingURL=chunk-SWEMPOSU.js.map