@koda-sl/baker-cli 0.447.0-dev.f5788a631 → 0.447.0

package/dist/chunk-UC6BWM5J.js

@@ -0,0 +1,159 @@
+import {
+  failApi
+} from "./chunk-E4MDJBLO.js";
+import {
+  CREATIVE_PERFORMANCE_DEFAULT_DAYS,
+  CREATIVE_PERFORMANCE_MAX_DAYS
+} from "./chunk-NDXBU22S.js";
+import {
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+
+// src/commands/creatives/performance.ts
+import { readFileSync } from "fs";
+import path from "path";
+import { defineCommand } from "citty";
+import { parse as parseYaml } from "yaml";
+var DESCRIPTION = `How each Baker creative is doing in the live Meta ads that show it: spend, impressions, CTR, CPC, results, cost per result, frequency and a fatigue verdict, next to the angle, hook, mechanism and dominant slot its definition set out to test. Video creatives add hookRate (percent of impressions that watched 3 seconds) and holdRate (percent of those that reached a ThruPlay). Use it before briefing new creatives, to learn which angle and mechanism to make next and which creatives to replace.
+
+Start here:
+  baker creatives performance                      # every creative in an ad, last 30 days
+  baker creatives performance --slug spring-offer  # one creative
+  baker creatives performance --days 14 --full     # ids, last-7-day figures, a video's watch funnel, one row per ad
+
+Fatigue follows the Meta playbook (07-creative-audit.md): fresh, fading, fatigued, dead, or too_early (under 14 days or 1,000 impressions) and no_delivery. A low hook rate means the first 3 seconds need new hooks; a working hook with a low hold rate means the body loses people. A creative counts once a Session's publish created an ad with it.`;
+var ARGS = {
+  slug: { type: "string", description: "Only this creative (src/creatives/<slug>/)", required: false },
+  days: {
+    type: "string",
+    description: `Reporting window in days, ending today (1-${CREATIVE_PERFORMANCE_MAX_DAYS}, default ${CREATIVE_PERFORMANCE_DEFAULT_DAYS})`,
+    required: false
+  },
+  full: {
+    type: "boolean",
+    description: "Add ids, last-7-day CTR and cost per result, and one row per ad",
+    required: false,
+    default: false
+  }
+};
+registerSchema({ command: "creatives.performance", description: DESCRIPTION, args: ARGS });
+var INSIGHT_KEYS = [
+  "idea",
+  "message",
+  "evidence",
+  "angle",
+  "hook",
+  "mechanism",
+  "dominantSlot",
+  "persona",
+  "awareness",
+  "hypothesis"
+];
+var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---/;
+function insightValue(value) {
+  if (typeof value === "string") return value.trim() || null;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return null;
+}
+function definitionInsights(markdown) {
+  const block = FRONTMATTER.exec(markdown)?.[1];
+  if (!block) return null;
+  let parsed;
+  try {
+    parsed = parseYaml(block);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object") return null;
+  const insights = {};
+  for (const [key, raw] of Object.entries(parsed)) {
+    if (!(INSIGHT_KEYS.includes(key) || key.startsWith("source") || key.startsWith("reference"))) continue;
+    const value = insightValue(raw);
+    if (value !== null) insights[key] = value;
+  }
+  return Object.keys(insights).length > 0 ? insights : null;
+}
+function readLocalDefinition(slug) {
+  try {
+    return readFileSync(path.join(process.cwd(), "src", "creatives", slug, "_definition.md"), "utf8");
+  } catch {
+    return null;
+  }
+}
+var COMPARED_FIELDS = [
+  { key: "angle", label: "angle", advice: "Brief the next creative on the cheapest angle with a new hook." },
+  { key: "mechanism", label: "mechanism", advice: "Brief the next creative on the cheapest mechanism." },
+  { key: "dominantSlot", label: "dominant slot", advice: "Lead the next creative with the cheapest dominant slot." }
+];
+function cheapestHint(creatives, { key, label, advice }) {
+  const byValue = /* @__PURE__ */ new Map();
+  for (const creative of creatives) {
+    const value = creative.definition?.[key];
+    if (!value || creative.costPerResult === null) continue;
+    const best = byValue.get(value);
+    if (!best || (best.costPerResult ?? Number.POSITIVE_INFINITY) > creative.costPerResult)
+      byValue.set(value, creative);
+  }
+  if (byValue.size < 2) return null;
+  const ranked = [...byValue.entries()].sort(([, a], [, b]) => (a.costPerResult ?? 0) - (b.costPerResult ?? 0)).map(
+    ([value, creative]) => `"${value}" ${creative.costPerResult}${creative.currency ? ` ${creative.currency}` : ""} (${creative.slug ?? creative.title})`
+  );
+  return `Cost per result by ${label}: ${ranked.join(", ")}. ${advice}`;
+}
+function withDefinitions(response, readDefinition) {
+  const creatives = response.data.creatives.map((creative) => {
+    const markdown = creative.slug ? readDefinition(creative.slug) : null;
+    const definition = markdown ? definitionInsights(markdown) : null;
+    return definition ? { ...creative, definition } : creative;
+  });
+  const hints = [...response.hints ?? []];
+  for (const field of COMPARED_FIELDS) {
+    const hint = cheapestHint(creatives, field);
+    if (hint) hints.push(hint);
+  }
+  const unnamed = creatives.filter((creative) => !creative.definition?.angle).map((c) => c.slug ?? c.title);
+  if (unnamed.length > 0) {
+    hints.push(
+      `No angle recorded for: ${unnamed.join(", ")}. Add angle and hook to src/creatives/<slug>/_definition.md so results show which angle works.`
+    );
+  }
+  return { ...response, data: { ...response.data, creatives }, ...hints.length > 0 ? { hints } : {} };
+}
+function parseDays(raw) {
+  if (raw === void 0) return void 0;
+  const days = Number(raw);
+  if (!Number.isInteger(days) || days < 1 || days > CREATIVE_PERFORMANCE_MAX_DAYS) {
+    throw new Error(`--days must be a whole number from 1 to ${CREATIVE_PERFORMANCE_MAX_DAYS}`);
+  }
+  return days;
+}
+var performanceCommand = defineCommand({
+  meta: { name: "performance", description: DESCRIPTION },
+  args: ARGS,
+  run: async ({ args }) => {
+    try {
+      const body = {};
+      const slug = args.slug;
+      if (slug) body.slug = slug;
+      const days = parseDays(args.days);
+      if (days !== void 0) body.days = days;
+      if (args.full) body.full = true;
+      const response = await apiPost("/api/creatives/performance", body);
+      writeJson(withDefinitions(response, readLocalDefinition));
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+
+export {
+  definitionInsights,
+  withDefinitions,
+  parseDays,
+  performanceCommand
+};
+//# sourceMappingURL=chunk-UC6BWM5J.js.map

package/dist/chunk-ULJ5RFOV.js

@@ -0,0 +1,76 @@
+import {
+  MODEL_REGISTRY,
+  isRegisteredModel
+} from "./chunk-CHSNHVYF.js";
+
+// src/commands/canvas/scaffold-common.ts
+import { access, readFile } from "fs/promises";
+
+// src/commands/canvas/composition-path.ts
+import { existsSync } from "fs";
+import path from "path";
+function resolveShippedCanvasDir(name, startDir, exists = existsSync, maxDepth = 8) {
+  const rel = path.join("canvas", name);
+  let dir = startDir;
+  for (let i = 0; i < maxDepth; i++) {
+    const candidate = path.join(dir, rel);
+    if (exists(path.join(candidate, "meta.json"))) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.resolve(startDir, "../../../", rel);
+}
+
+// src/commands/canvas/scaffold-common.ts
+var SHIPPED_OVERLAY_COMPOSITION_DIR = resolveShippedCanvasDir(
+  "video-overlay-composition",
+  import.meta.dirname
+);
+var SHIPPED_CAPTIONS_DIR = resolveShippedCanvasDir("tiktok-captions-composition", import.meta.dirname);
+function resolveModel(kind, requested, fallback) {
+  const model = requested ? String(requested) : fallback;
+  if (isRegisteredModel(kind, model)) return model;
+  const known = Object.keys(MODEL_REGISTRY[kind]).join(", ");
+  throw new Error(`"${model}" is not a ${kind} model. Use one of: ${known}`);
+}
+async function loadAssetText(ref, label) {
+  const r = ref;
+  if (typeof r?.path === "string") return readFile(r.path, "utf8");
+  if (typeof r?.url === "string") {
+    const res = await fetch(r.url);
+    if (!res.ok) throw new Error(`failed to fetch ${label} (${res.status})`);
+    return res.text();
+  }
+  throw new Error(`${label}: output had no readable path or url`);
+}
+function parseElements(raw) {
+  const parsed = JSON.parse(raw);
+  if (Array.isArray(parsed)) return parsed;
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed.elements)) {
+    return parsed.elements;
+  }
+  return [];
+}
+function fail(code, message) {
+  process.stderr.write(`${JSON.stringify({ ok: false, error: { code, message } }, null, 2)}
+`);
+  process.exit(2);
+}
+function fileExists(target) {
+  return access(target).then(
+    () => true,
+    () => false
+  );
+}
+
+export {
+  SHIPPED_OVERLAY_COMPOSITION_DIR,
+  SHIPPED_CAPTIONS_DIR,
+  resolveModel,
+  loadAssetText,
+  parseElements,
+  fail,
+  fileExists
+};
+//# sourceMappingURL=chunk-ULJ5RFOV.js.map

package/dist/chunk-VAISMQQB.js

@@ -0,0 +1,346 @@
+import {
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-6DB2B3GF.js";
+import {
+  adCopyHints,
+  booleanWordPositionalError,
+  capabilityFix
+} from "./chunk-GIJT3A5U.js";
+import {
+  withHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-VFIOJD5M.js";
+import {
+  LINKEDIN_DRAFT_BATCH_MAX,
+  linkedinDraftOpInputSchema
+} from "./chunk-NDXBU22S.js";
+import {
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import {
+  requireChatId
+} from "./chunk-NAWWC5I3.js";
+
+// src/commands/ads/linkedin/write-shared.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+var TOTAL_BUDGET_HELP = "Lifetime budget \u2014 on something already running it must exceed spend to date, or LinkedIn rejects it";
+function bareAccountId(args) {
+  const raw = resolveAccountIdArg(args);
+  return raw.replace(/^urn:li:sponsoredAccount:/, "").replace(/^sponsoredAccount:/, "");
+}
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function loadJsonFileArg(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation(`${path} must contain a JSON object`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`${path} is not valid JSON: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function mergePayload(file, flags) {
+  const merged = { ...file };
+  for (const [key, value] of Object.entries(flags)) {
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function loadPatchArg(args) {
+  const file = typeof args.file === "string" && args.file.length > 0 ? args.file : void 0;
+  const inline = typeof args.patch === "string" && args.patch.length > 0 ? args.patch : void 0;
+  if (Boolean(file) === Boolean(inline)) {
+    failWriteValidation("pass exactly one of --file <patch.json> or --patch '<json>'");
+  }
+  if (file) {
+    return loadJsonFileArg(file);
+  }
+  try {
+    const parsed = JSON.parse(inline);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation("--patch must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`--patch is not valid JSON: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function parseMoneyFlag(amount, currency, flag) {
+  if (amount === void 0 || amount === null || amount === "") {
+    return void 0;
+  }
+  if (currency === void 0 || currency === null || currency === "") {
+    return { amount: String(amount) };
+  }
+  if (typeof currency !== "string" || currency.length !== 3) {
+    failWriteValidation(`${flag} got an invalid --currency (expected a 3-letter code like EUR)`);
+  }
+  return { amount: String(amount), currencyCode: currency.toUpperCase() };
+}
+function parseDateFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const raw = String(value);
+  if (/^\d{10,}$/.test(raw)) {
+    return Number(raw);
+  }
+  const parsed = Date.parse(raw);
+  if (Number.isNaN(parsed)) {
+    failWriteValidation(`${flag} must be an ISO date (2026-07-10) or epoch milliseconds`);
+  }
+  return parsed;
+}
+function parseOnOffFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const raw = String(value).toLowerCase();
+  if (raw === "on" || raw === "true") {
+    return true;
+  }
+  if (raw === "off" || raw === "false") {
+    return false;
+  }
+  failWriteValidation(`${flag} must be on|off`);
+}
+function parseLocaleFlag(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const match = /^([a-z]{2})[_-]([A-Za-z]{2})$/.exec(String(value));
+  if (!match) {
+    failWriteValidation("--locale must look like en_US (language_COUNTRY)");
+  }
+  return { language: match[1], country: match[2].toUpperCase() };
+}
+function loadTargetingFileArg(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return void 0;
+  }
+  const parsed = loadJsonFileArg(path);
+  const criteria = parsed.targetingCriteria ?? parsed;
+  if (!criteria.include) {
+    failWriteValidation(
+      `${path} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+    );
+  }
+  return criteria;
+}
+function sha256Lower(value) {
+  return createHash("sha256").update(value.trim().toLowerCase()).digest("hex");
+}
+function parseCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        current += char;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === ",") {
+      cells.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  cells.push(current);
+  return cells.map((cell) => cell.trim());
+}
+function parseListFileArg(path, maxRows) {
+  if (typeof path !== "string" || path.length === 0) {
+    return void 0;
+  }
+  const raw = readFileSync(path, "utf8");
+  const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  if (lines.length < 2) {
+    failWriteValidation(`${path} needs a header row and at least one data row`);
+  }
+  const columns = parseCsvLine(lines[0]).map((column) => column.trim());
+  const rows = [];
+  for (const line of lines.slice(1)) {
+    const cells = parseCsvLine(line);
+    const row = {};
+    columns.forEach((column, index) => {
+      const value = cells[index] ?? "";
+      if (!value) {
+        return;
+      }
+      row[column] = column.toLowerCase() === "email" ? sha256Lower(value) : value;
+    });
+    if (Object.keys(row).length > 0) {
+      rows.push(row);
+    }
+  }
+  if (rows.length > maxRows) {
+    failWriteValidation(`${path} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+  }
+  return { columns, rows };
+}
+function failPreflight(fields) {
+  writeJsonEnvelope({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: fields.map((field) => field.path ? `${field.path}: ${field.message}` : field.message).join("; "),
+      fields,
+      fix: capabilityFix("linkedin-ads")
+    }
+  });
+  process.exit(1);
+}
+var BATCH_NUDGE = "This command takes several ids at once \u2014 pass them comma-separated or with --ids-file instead of one call per id.";
+function batchNudge(data) {
+  return data.sameKindStaged === void 0 ? [] : [BATCH_NUDGE];
+}
+async function stageOp(raw, hints) {
+  const preflight = linkedinDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    failPreflight(preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message })));
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/linkedin/draft/stage", {
+      chatId,
+      op: preflight.data
+    });
+    const allHints = [...batchNudge(response.data), ...hints ?? [], ...await adCopyHints(preflight.data)];
+    writeJsonEnvelope(withHints(response, allHints));
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+async function stageLinkedinOps(rawOps, hints) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageOp(rawOps[0], hints);
+    return;
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = linkedinDraftOpInputSchema.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);
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/linkedin/draft/stage-batch", { chatId, ops });
+    const allHints = [...hints ?? [], ...await adCopyHints(ops)];
+    writeJsonEnvelope(withHints(response, allHints));
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+async function stageStatusChange(input) {
+  const payload = input.kind === "creative.update" ? { intendedStatus: input.status } : { status: input.status };
+  await stageLinkedinOps(
+    input.targets.map((target) => ({ kind: input.kind, accountId: input.accountId, target, payload }))
+  );
+}
+function requireTarget(args, entity) {
+  const inverted = booleanWordPositionalError(args, entity);
+  if (inverted !== void 0) {
+    failWriteValidation(inverted);
+  }
+  const positionals = readPositionals(args);
+  const target = args.id ?? args.target ?? args.ref ?? positionals[0];
+  if (typeof target !== "string" || target.length === 0) {
+    failWriteValidation(`pass the ${entity} id or URN as the positional argument`);
+  }
+  if (positionals.length > 1 || splitIdList(target).length > 1) {
+    failWriteValidation(
+      `this command takes one ${entity} id \u2014 run it once per id. Only pause/resume/archive and 'creatives update' accept several ids in one call.`
+    );
+  }
+  return target;
+}
+function readPositionals(args) {
+  if (!Array.isArray(args._)) {
+    return [];
+  }
+  return args._.filter((value) => typeof value === "string" && value.length > 0);
+}
+function splitIdList(raw) {
+  return raw.split(",").map((id) => id.trim()).filter(Boolean);
+}
+function idsFileEntries(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return [];
+  }
+  return readFileSync(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+}
+function requireTargets(args, entity) {
+  const positionals = readPositionals(args);
+  const named = [args.id, args.target, args.ref].filter(
+    (value) => typeof value === "string" && value.length > 0
+  );
+  const fromArgs = positionals.length > 0 ? positionals : named;
+  const targets = [.../* @__PURE__ */ new Set([...fromArgs.flatMap(splitIdList), ...idsFileEntries(args["ids-file"])])];
+  if (targets.length === 0) {
+    failWriteValidation(
+      `pass the ${entity} id or URN as the positional argument (comma-separated for several), or --ids-file <path>`
+    );
+  }
+  if (targets.length > LINKEDIN_DRAFT_BATCH_MAX) {
+    failWriteValidation(
+      `${targets.length} ids exceeds the batch limit of ${LINKEDIN_DRAFT_BATCH_MAX} \u2014 split the list`
+    );
+  }
+  return targets;
+}
+
+export {
+  TOTAL_BUDGET_HELP,
+  bareAccountId,
+  failWriteValidation,
+  loadJsonFileArg,
+  mergePayload,
+  loadPatchArg,
+  parseMoneyFlag,
+  parseDateFlag,
+  parseOnOffFlag,
+  parseLocaleFlag,
+  loadTargetingFileArg,
+  parseListFileArg,
+  stageOp,
+  stageLinkedinOps,
+  stageStatusChange,
+  requireTarget,
+  requireTargets
+};
+//# sourceMappingURL=chunk-VAISMQQB.js.map