@koda-sl/baker-cli 0.574.0-dev.19539e5a8 → 0.575.0-dev.85f21462e

package/dist/chunk-JGMQD3PX.js

@@ -0,0 +1,274 @@
+import {
+  chatgptDraftOpInputSchema,
+  chatgptFailure
+} from "./chunk-C57NXUM2.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-VJUVTMHY.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+import {
+  requireChatId
+} from "./chunk-OMLZ35HJ.js";
+import {
+  registerSchema
+} from "./chunk-NXNOXZGB.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-JGMQD3PX.js.map

package/dist/chunk-JTAPNHW5.js

@@ -0,0 +1,98 @@
+import {
+  isRemoteUrl
+} from "./chunk-CP5IVVYM.js";
+import {
+  detectImageContentType,
+  uploadLocalImage
+} from "./chunk-VVITBZKP.js";
+import {
+  IMAGE_GENERATE_MODELS,
+  MODEL_REGISTRY,
+  VIDEO_GENERATE_MODELS
+} from "./chunk-F3CZFUXZ.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+
+// src/commands/studio/modelOptions.ts
+function unionOfStringEnum(node, models, param) {
+  const values = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const schema = MODEL_REGISTRY[node][model]?.params[param];
+    if (schema?.kind === "string") for (const value of schema.enum ?? []) values.add(value);
+  }
+  return [...values];
+}
+function unionOfNumberEnum(node, models, param) {
+  const values = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const schema = MODEL_REGISTRY[node][model]?.params[param];
+    if (schema?.kind === "number") for (const value of schema.enum ?? []) values.add(value);
+  }
+  return [...values].sort((a, b) => a - b);
+}
+var IMAGE_MODEL_IDS = [...IMAGE_GENERATE_MODELS];
+var VIDEO_MODEL_IDS = [...VIDEO_GENERATE_MODELS];
+var IMAGE_SIZES = unionOfStringEnum("image_generate", IMAGE_GENERATE_MODELS, "image_size");
+var IMAGE_QUALITIES = unionOfStringEnum("image_generate", IMAGE_GENERATE_MODELS, "quality");
+var CLIP_RESOLUTIONS = unionOfStringEnum("video_generate", VIDEO_GENERATE_MODELS, "resolution");
+var CLIP_DURATIONS = unionOfNumberEnum("video_generate", VIDEO_GENERATE_MODELS, "duration");
+var CLIP_PERSON_GENERATION = unionOfStringEnum("video_generate", VIDEO_GENERATE_MODELS, "person_generation");
+
+// src/commands/studio/references.ts
+var LIBRARY_ID_RE = /^[a-z0-9]{16,}$/i;
+var FILE_EXTENSION_RE = /\.[a-z0-9]{2,5}$/i;
+var PATH_HINT_RE = /[/\\]/;
+function classify(entry) {
+  if (isRemoteUrl(entry)) return { kind: "url", value: entry };
+  if (PATH_HINT_RE.test(entry) || FILE_EXTENSION_RE.test(entry)) return { kind: "path", value: entry };
+  if (LIBRARY_ID_RE.test(entry)) return { kind: "id", value: entry };
+  throw new ApiError(
+    "VALIDATION_ERROR",
+    `"${entry}" is not a library image id, a file path, or an image URL. Pass a comma-separated mix of those.`
+  );
+}
+function parseImageRefs(spec) {
+  return spec.split(",").map((entry) => entry.trim()).filter(Boolean).map(classify);
+}
+var defaultDeps = {
+  ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
+  upload: (path) => uploadLocalImage({ file: path, contentType: detectImageContentType(path), source: "uploaded" })
+};
+async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
+  const refs = parseImageRefs(spec);
+  if (limit && refs.length > limit.max) {
+    throw new ApiError("VALIDATION_ERROR", limit.refuse(refs.length));
+  }
+  const imageIds = [];
+  const added = [];
+  for (const ref of refs) {
+    if (ref.kind === "id") {
+      imageIds.push(ref.value);
+      continue;
+    }
+    const { imageId } = ref.kind === "url" ? await deps.ingest(ref.value) : await deps.upload(ref.value).catch(uploadFailure(ref.value));
+    imageIds.push(imageId);
+    added.push(imageId);
+  }
+  return { imageIds, added };
+}
+function uploadFailure(path) {
+  return (error) => {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path}" as an image.`);
+  };
+}
+
+export {
+  IMAGE_MODEL_IDS,
+  VIDEO_MODEL_IDS,
+  IMAGE_SIZES,
+  IMAGE_QUALITIES,
+  CLIP_RESOLUTIONS,
+  CLIP_DURATIONS,
+  CLIP_PERSON_GENERATION,
+  resolveLibraryImageIds
+};
+//# sourceMappingURL=chunk-JTAPNHW5.js.map

package/dist/chunk-K2DKQ52D.js

@@ -0,0 +1,89 @@
+import {
+  readAvatars
+} from "./chunk-DN6EMVA4.js";
+import {
+  readCompanyReading
+} from "./chunk-CNZ5KS4I.js";
+import {
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+
+// src/commands/creatives/cast-inventory.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+var short = (text, max) => text.length > max ? `${text.slice(0, max - 1).trimEnd()}\u2026` : text;
+var nameKey = (name) => name.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase().replace(/\b(?:inc|llc|ltd|gmbh|sl|sa|corp|co)\b\.?/g, "").replace(/[^\p{L}\p{N}]/gu, "");
+function isTheCompany(employer, company) {
+  const key = nameKey(employer);
+  if (key.length < 3) return false;
+  return [company.name ?? "", ...company.brands ?? []].some((own) => {
+    const ownKey = nameKey(own);
+    return ownKey.length >= 3 && (key.includes(ownKey) || ownKey.includes(key));
+  });
+}
+function avatarRelation(avatar, company) {
+  if (avatar.relation) return avatar.relation;
+  if (avatar.likeness === "synthetic" && !avatar.person) return "role";
+  return avatar.person?.company && isTheCompany(avatar.person.company, company) ? "team" : "unknown";
+}
+var CASTABLE = ["team", "founder", "role"];
+function avatarsOf(response, company = {}) {
+  return response.avatars.filter((a) => a.status === "ready").map((a) => {
+    const real = a.likeness === "licensed" || Boolean(a.person);
+    const role = [a.person?.role, a.person?.company].filter(Boolean).join(" at ");
+    const relation = avatarRelation(a, company);
+    return {
+      handle: a.handle,
+      real,
+      who: short(role || a.subjectDescription || a.name, 90),
+      relation,
+      castable: CASTABLE.includes(relation),
+      ...a.testimonialIds?.length ? { testimonialIds: a.testimonialIds } : {}
+    };
+  });
+}
+async function companyName(root) {
+  const doc = await readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => "");
+  const title = /^#\s+(.+?)\s*$/m.exec(doc)?.[1] ?? "";
+  return title.replace(/[*_`]/g, "").replace(/^(?:company|empresa|compañía)\s*:\s*/i, "") || void 0;
+}
+async function castCompany(root) {
+  const [name, reading] = await Promise.all([companyName(root), readCompanyReading(root).catch(() => null)]);
+  return { ...name ? { name } : {}, brands: reading?.brands ?? [] };
+}
+function customersOf(found) {
+  return found.filter((t) => t.sentiment !== "negative" && (t.highlight || t.reviewText).trim()).slice(0, 3).map((t) => ({
+    ...t.reviewerName ? { name: t.reviewerName } : {},
+    words: short((t.highlight || t.reviewText).trim().replace(/\s+/g, " "), 140),
+    source: t.sourceType,
+    photo: Boolean(t.reviewerImageUrl || t.reviewerImageId || t.imageIds?.length || t.videoIds?.length)
+  }));
+}
+var LOGO_FILE = /\.(svg|png|webp|jpe?g)$/i;
+async function castInventory(root, message, company) {
+  const own = await castCompany(root);
+  const [avatars, customers, logos] = await Promise.all([
+    readAvatars("/api/avatars", { status: "ready" }).then(
+      (response) => avatarsOf(response, { ...own, ...company ? { name: company } : {} }),
+      () => []
+    ),
+    apiPost("/api/testimonials/search", { query: message, limit: 6 }).then(
+      customersOf,
+      () => []
+    ),
+    readdir(path.join(root, "src", "brand", "logos")).then(
+      (files) => files.filter((f) => LOGO_FILE.test(f)).map((f) => `src/brand/logos/${f}`),
+      () => []
+    )
+  ]);
+  return { avatars, customers, logos, ...company ? { company } : {} };
+}
+
+export {
+  avatarRelation,
+  avatarsOf,
+  companyName,
+  castCompany,
+  castInventory
+};
+//# sourceMappingURL=chunk-K2DKQ52D.js.map

package/dist/chunk-K3VMHRLJ.js

@@ -0,0 +1,61 @@
+import {
+  COST_TYPES,
+  OBJECTIVE_TYPES,
+  calendarDaySchema,
+  targetingCriteriaSchema
+} from "./chunk-BTOGDXA4.js";
+
+// ../api/src/ads-linkedin/planning.ts
+import { z } from "zod";
+var moneySchema = z.object({
+  amount: z.string().regex(/^\d+(\.\d+)?$/, "use a plain amount such as 250 or 5.57"),
+  currencyCode: z.string().regex(/^[A-Z]{3}$/).optional()
+});
+var accountIdSchema = z.string().min(1);
+var linkedinBidPricingRequestSchema = z.object({
+  accountId: accountIdSchema,
+  objectiveType: z.enum(OBJECTIVE_TYPES),
+  costType: z.enum(COST_TYPES).default("CPC"),
+  campaignType: z.enum(["SPONSORED_UPDATES", "TEXT_AD", "SPONSORED_INMAILS"]).default("SPONSORED_UPDATES"),
+  /** EXACT = audience expansion off, the playbook default. */
+  matchType: z.enum(["EXACT", "AUDIENCE_EXPANDED"]).default("EXACT"),
+  targetingCriteria: targetingCriteriaSchema,
+  skipCache: z.boolean().optional()
+});
+var LINKEDIN_FORECAST_DEFAULT_DAYS = 30;
+var linkedinForecastRequestSchema = z.object({
+  accountId: accountIdSchema,
+  objectiveType: z.enum(OBJECTIVE_TYPES).optional(),
+  costType: z.enum(COST_TYPES).default("CPC"),
+  campaignType: z.enum(["SPONSORED_UPDATES", "SPONSORED_INMAILS", "DYNAMIC"]).default("SPONSORED_UPDATES"),
+  /** First forecast day (UTC); defaults to tomorrow — LinkedIn forecasts only the future. */
+  startDate: calendarDaySchema.optional(),
+  days: z.number().int().min(1).max(365).default(LINKEDIN_FORECAST_DEFAULT_DAYS),
+  dailyBudget: moneySchema.optional(),
+  totalBudget: moneySchema.optional(),
+  /** A manual bid; without one LinkedIn forecasts its automated bidding. */
+  bid: moneySchema.optional(),
+  optimizationTarget: z.string().regex(/^[A-Z_]+$/).optional(),
+  targetingCriteria: targetingCriteriaSchema,
+  /** Add LinkedIn's raw series (daily, 7-day, 30-day) to the summary. */
+  full: z.boolean().default(false),
+  skipCache: z.boolean().optional()
+}).superRefine((req, ctx) => {
+  if (!req.dailyBudget && !req.totalBudget) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["totalBudget"],
+      message: "a budget is required (daily or total) \u2014 LinkedIn forecasts what a budget buys"
+    });
+  }
+  if (req.dailyBudget && req.totalBudget) {
+    ctx.addIssue({ code: "custom", path: ["totalBudget"], message: "pass a daily or a total budget, not both" });
+  }
+});
+
+export {
+  linkedinBidPricingRequestSchema,
+  LINKEDIN_FORECAST_DEFAULT_DAYS,
+  linkedinForecastRequestSchema
+};
+//# sourceMappingURL=chunk-K3VMHRLJ.js.map