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

package/dist/chunk-AQPDH3QJ.js

@@ -0,0 +1,97 @@
+import {
+  claimNewCreativeInWorkspace,
+  creativeLimitRefusal
+} from "./chunk-XVFZDPEW.js";
+import {
+  leadVersion,
+  writeSeriesMemberCanvas
+} from "./chunk-3X44LRUQ.js";
+import {
+  definitionFieldsOf,
+  setDefinitionFields,
+  setSpecMessage
+} from "./chunk-IQASMSVP.js";
+import {
+  IDEAS_DIR
+} from "./chunk-2WBQBXFJ.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-AQPDH3QJ.js.map

package/dist/chunk-BFMNK4YF.js

@@ -0,0 +1,64 @@
+import {
+  REF_PREFIX
+} from "./chunk-F6DDX2RT.js";
+
+// src/commands/canvas/node-preview.ts
+var MAX_PARAMS_PREVIEW_LENGTH = 4e3;
+var SPEC_KEYS = [
+  "model",
+  "format",
+  "mode",
+  "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 own = params;
+  const nested = (key) => own[key] && typeof own[key] === "object" && !Array.isArray(own[key]) ? own[key] : {};
+  const record = { ...nested("paint"), ...nested("words"), ...own };
+  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-BFMNK4YF.js.map

package/dist/chunk-BYG6MZLI.js

@@ -0,0 +1,228 @@
+import {
+  NUMERIC_ID_REGEX
+} from "./chunk-C6JPTPPU.js";
+
+// ../api/src/ads-google/change-history.ts
+var CHANGE_SCOPES = ["detail", "summary"];
+var CHANGE_SCOPE_MAX_DAYS = {
+  detail: 30,
+  summary: 90
+};
+var DEFAULT_CHANGE_DAYS = 7;
+var MAX_CHANGE_DAYS = CHANGE_SCOPE_MAX_DAYS.summary;
+function isChangeLookbackWithinReach(days, scope) {
+  return days <= CHANGE_SCOPE_MAX_DAYS[scope];
+}
+
+// ../api/src/ads-google/keyword-planning.ts
+import { z } from "zod";
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var micros = z.number().int().positive();
+var FORECAST_MATCH_TYPES = ["EXACT", "PHRASE", "BROAD"];
+var googleForecastBiddingSchema = z.discriminatedUnion("strategy", [
+  z.object({ strategy: z.literal("MANUAL_CPC"), maxCpcBidMicros: micros, dailyBudgetMicros: micros.optional() }),
+  z.object({
+    strategy: z.literal("MAXIMIZE_CLICKS"),
+    dailyTargetSpendMicros: micros,
+    maxCpcBidCeilingMicros: micros.optional()
+  }),
+  z.object({ strategy: z.literal("MAXIMIZE_CONVERSIONS"), dailyTargetSpendMicros: micros })
+]);
+var googleKeywordForecastRequestSchema = z.object({
+  customerId: z.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z.string().optional(),
+  /** One forecast ad group per entry; most forecasts are a single group. */
+  adGroups: z.array(
+    z.object({
+      keywords: z.array(z.object({ text: z.string().trim().min(1).max(80), matchType: z.enum(FORECAST_MATCH_TYPES) })).min(1)
+    })
+  ).min(1),
+  locationIds: z.array(z.string().regex(NUMERIC_ID_REGEX)).optional(),
+  languageId: z.string().regex(NUMERIC_ID_REGEX).optional(),
+  bidding: googleForecastBiddingSchema,
+  /** Must start in the future and end within a year. Without them Baker forecasts the 30 days from tomorrow. */
+  startDate: z.string().regex(ISO_DATE).optional(),
+  endDate: z.string().regex(ISO_DATE).optional(),
+  currencyCode: z.string().length(3).optional()
+}).refine((body) => body.startDate === void 0 === (body.endDate === void 0), {
+  message: "Give both --start and --end, or neither (the forecast then covers the 30 days from tomorrow)",
+  path: ["endDate"]
+});
+var KEYWORD_FORECAST_SOURCE = "keyword_planner_forecast";
+var googleKeywordForecastResponseSchema = z.object({
+  source: z.literal(KEYWORD_FORECAST_SOURCE),
+  period: z.object({ startDate: z.string(), endDate: z.string() }),
+  forecast_clicks: z.number().nullable(),
+  forecast_cost_micros: z.number().nullable(),
+  forecast_conversions: z.number().nullable(),
+  forecast_average_cpc_micros: z.number().nullable(),
+  forecast_average_cpa_micros: z.number().nullable()
+});
+var googleAdGroupThemesRequestSchema = z.object({
+  customerId: z.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z.string().optional(),
+  keywords: z.array(z.string().trim().min(1)).min(1),
+  /** Existing ad groups to sort the keywords into: numeric ids or `customers/{cid}/adGroups/{id}`. */
+  adGroups: z.array(z.string().min(1)).min(1)
+});
+var googleAdGroupThemesResponseSchema = z.object({
+  suggestions: z.array(
+    z.object({
+      keyword: z.string(),
+      suggested_keyword: z.string(),
+      match_type: z.string(),
+      ad_group: z.string(),
+      campaign: z.string()
+    })
+  ),
+  unusable_ad_groups: z.array(z.object({ ad_group: z.string(), campaign: z.string() }))
+});
+
+// ../api/src/ads-google/url-options.ts
+import { z as z2 } from "zod";
+var URL_OPTION_LEVELS = ["account", "campaign", "ad_group", "ad"];
+var googleUrlOptionValueSchema = z2.discriminatedUnion("state", [
+  z2.object({ state: z2.literal("set"), value: z2.string() }),
+  z2.object({ state: z2.literal("not_set") }),
+  z2.object({ state: z2.literal("not_read"), reason: z2.string() })
+]);
+var googleUrlOptionsRequestSchema = z2.object({
+  customerId: z2.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z2.string().optional(),
+  /** Compact by default: only campaigns that actually override the account. `full` lists every campaign. */
+  full: z2.boolean().optional(),
+  skipCache: z2.boolean().optional()
+});
+var googleUrlOptionsCampaignSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  status: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsAdGroupSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  status: z2.string(),
+  campaign_id: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsAdSchema = z2.object({
+  id: z2.string(),
+  status: z2.string(),
+  ad_group_id: z2.string(),
+  campaign_id: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsResponseSchema = z2.object({
+  customer_id: z2.string(),
+  account: z2.object({
+    level: z2.literal("account"),
+    read: z2.boolean(),
+    final_url_suffix: googleUrlOptionValueSchema,
+    tracking_url_template: googleUrlOptionValueSchema
+  }),
+  campaigns: z2.object({
+    level: z2.literal("campaign"),
+    read: z2.boolean(),
+    /** Campaigns actually observed. 0 with `read: true` means the account has no non-removed campaigns. */
+    campaigns_read: z2.number().int().nonnegative(),
+    /** Campaigns observed to carry no override of their own — an explicit finding, not an omission. */
+    campaigns_without_override: z2.number().int().nonnegative(),
+    overrides: z2.array(googleUrlOptionsCampaignSchema),
+    /** Compact mode only: campaigns read but not listed because they carry no override. */
+    omitted: z2.number().int().nonnegative()
+  }),
+  /**
+   * Ad groups and ads that carry an override of their own — read by asking Google only for the
+   * entities whose suffix or template IS NOT NULL, so an account of thousands of ads costs one page.
+   * `read: true` with no overrides is a finding: nothing at this level overrides the levels above.
+   * `truncated` means more overriding entities exist than one page listed.
+   */
+  ad_groups: z2.object({
+    level: z2.literal("ad_group"),
+    read: z2.boolean(),
+    overrides: z2.array(googleUrlOptionsAdGroupSchema),
+    truncated: z2.boolean()
+  }),
+  ads: z2.object({
+    level: z2.literal("ad"),
+    read: z2.boolean(),
+    overrides: z2.array(googleUrlOptionsAdSchema),
+    truncated: z2.boolean()
+  }),
+  /** Levels this command could not read. Nothing here may be reported as "not configured". */
+  levels_not_read: z2.array(z2.object({ level: z2.enum(URL_OPTION_LEVELS), reason: z2.string() }))
+});
+var ACCOUNT_URL_OPTIONS_LOCATION = "Google Ads UI \u2192 Admin \u2192 Account settings \u2192 Tracking (account-level tracking template and final URL suffix)";
+var ACCOUNT_URL_OPTIONS_STAGE_COMMAND = 'baker ads google account update --customer-id <id> --final-url-suffix "utm_agency=baker"';
+function isSet(value) {
+  return value.state === "set";
+}
+function entityOverrideHints(label, plural, field, level) {
+  if (!level.read) return [];
+  const hints = [];
+  const overriding = level.overrides.filter((entity) => isSet(entity.final_url_suffix));
+  if (overriding.length > 0) {
+    const named = overriding.slice(0, 5).map((entity) => entity.name || entity.id).join(", ");
+    hints.push(
+      `${overriding.length} ${label}(s) set their own final URL suffix (${named}${overriding.length > 5 ? ", \u2026" : ""}). It REPLACES the campaign and account suffix for every click through it, so an account-wide parameter must be added to theirs too.`
+    );
+  }
+  if (level.truncated) {
+    hints.push(
+      `More ${plural} override the URL options than one page lists \u2014 read them all with \`baker ads google query\` on ${field}.final_url_suffix IS NOT NULL --all before saying which ones do.`
+    );
+  }
+  return hints;
+}
+function urlOptionsHints(report) {
+  const hints = [];
+  const { account, campaigns } = report;
+  if (!account.read) {
+    hints.push(
+      "The account level did NOT read \u2014 its URL options are unknown, not empty. Re-run before telling the user anything about account-wide tagging."
+    );
+  } else if (account.final_url_suffix.state === "not_set") {
+    hints.push(
+      `No account-level final URL suffix is set. An account-wide parameter (agency/partner tagging such as utm_agency=\u2026) belongs at the account level so it reaches every ad \u2014 stage it with \`${ACCOUNT_URL_OPTIONS_STAGE_COMMAND}\` (applies at Publish; the user sees it under ${ACCOUNT_URL_OPTIONS_LOCATION}).`
+    );
+  }
+  if (!campaigns.read) {
+    hints.push(
+      "Campaign-level URL options did NOT read \u2014 do not report that no campaign overrides exist. Re-run before concluding."
+    );
+  } else {
+    const overriding = campaigns.overrides.filter((c) => isSet(c.final_url_suffix));
+    if (overriding.length > 0) {
+      const named = overriding.slice(0, 5).map((c) => c.name || c.id).join(", ");
+      hints.push(
+        `A campaign's final URL suffix REPLACES the account-level one for that campaign \u2014 it does not merge. ${overriding.length} campaign(s) set their own (${named}${overriding.length > 5 ? ", \u2026" : ""}) and will not pick up an account-wide parameter until their own suffix carries it too. Every other campaign read here inherits the account level normally.`
+      );
+    }
+  }
+  hints.push(...entityOverrideHints("ad group", "ad groups", "ad_group", report.ad_groups));
+  hints.push(...entityOverrideHints("ad", "ads", "ad_group_ad.ad", report.ads));
+  const overridingLevelsNotRead = report.levels_not_read.filter((level) => level.level !== "account");
+  if (overridingLevelsNotRead.length > 0) {
+    hints.push(
+      `Not read at this level: ${overridingLevelsNotRead.map((l) => l.level).join(", ")}. A suffix set there still wins over the levels above it.`
+    );
+  }
+  if (campaigns.omitted > 0) {
+    hints.push(`${campaigns.omitted} campaign(s) read with no override of their own are not listed \u2014 pass --full.`);
+  }
+  return hints;
+}
+
+export {
+  CHANGE_SCOPES,
+  CHANGE_SCOPE_MAX_DAYS,
+  DEFAULT_CHANGE_DAYS,
+  isChangeLookbackWithinReach,
+  googleKeywordForecastRequestSchema,
+  urlOptionsHints
+};
+//# sourceMappingURL=chunk-BYG6MZLI.js.map