@koda-sl/baker-cli 0.489.0 → 0.491.0

package/dist/chunk-TG4NCHFS.js

@@ -0,0 +1,142 @@
+import {
+  avatarsOf
+} from "./chunk-PUSBUMYM.js";
+import {
+  readAvatars
+} from "./chunk-LCW3U4EA.js";
+import {
+  readCreativeContext,
+  workspaceOfCreative
+} from "./chunk-SGEPZB3D.js";
+import {
+  frontmatterOf,
+  ruleTells
+} from "./chunk-G2LGMWNG.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-23H4ZJRP.js";
+import {
+  isAdSpec,
+  nativeCopy,
+  readAdSpec
+} from "./chunk-4AMIHNNP.js";
+import {
+  marketFromCompanyDoc
+} from "./chunk-2WZI36D3.js";
+
+// src/engine/creative-context/ad-words.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+var json = (file) => readFile(file, "utf8").then((raw) => JSON.parse(raw)).catch(() => null);
+var text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+function waivedOf(spec) {
+  const waive = spec?.waive;
+  return Array.isArray(waive) ? waive.flatMap((w) => text(w?.rule) ?? []) : [];
+}
+function sceneWords(scene) {
+  const s = scene ?? {};
+  const spoken = Array.isArray(s.dialogue) ? s.dialogue.flatMap((d) => text(d?.line) ?? []) : [];
+  const shown = Array.isArray(s.overlays) ? s.overlays.flatMap((o) => text(o?.text) ?? []) : [];
+  return [...spoken, ...shown];
+}
+async function sceneFiles(creativeDir) {
+  const dir = path.join(creativeDir, "scenes");
+  const files = (await readdir(dir).catch(() => [])).filter((f) => f.endsWith(".json")).sort();
+  return await Promise.all(files.map((f) => json(path.join(dir, f))));
+}
+async function videoLanguage(creativeDir) {
+  const definition = frontmatterOf(await readFile(path.join(creativeDir, "_definition.md"), "utf8").catch(() => ""));
+  const beats = await json(path.join(creativeDir, "ad.spec.json"));
+  return text(definition?.language) ?? text(beats?.voice?.language);
+}
+async function videoWords(raw, creativeDir) {
+  const global = raw.global ?? {};
+  const transcript = text(global.transcript);
+  const scenes = [...Array.isArray(raw.scenes) ? raw.scenes : [], ...await sceneFiles(creativeDir)];
+  const lines = [.../* @__PURE__ */ new Set([...transcript ? [transcript] : [], ...scenes.flatMap(sceneWords)])];
+  const language = await videoLanguage(creativeDir);
+  return { kind: "video", lines, ...language ? { language } : {} };
+}
+function staticWords(raw) {
+  try {
+    const spec = readAdSpec(raw);
+    const lines = spec.native ? nativeCopy(spec.native) : spec.copy.map((l) => l.text);
+    const language = spec.viewer?.market?.language;
+    return { kind: "static", lines, ...language ? { language } : {} };
+  } catch {
+    return null;
+  }
+}
+async function readAdWords(creativeDir) {
+  const raw = await json(path.join(creativeDir, "prompt.json"));
+  if (!raw || typeof raw !== "object") return null;
+  const video = !isAdSpec(raw) && ("global" in raw || "scenes" in raw);
+  const words = video ? await videoWords(raw, creativeDir) : staticWords(raw);
+  if (!words) return null;
+  const product = text(raw.product);
+  const definition = frontmatterOf(await readFile(path.join(creativeDir, "_definition.md"), "utf8").catch(() => ""));
+  const platform = text(definition?.platform);
+  const listed = definition?.platforms;
+  const platforms = Array.isArray(listed) ? listed.map(text).filter((p) => p !== void 0) : [];
+  return {
+    ...words,
+    ...product ? { product } : {},
+    ...platform ? { platform } : {},
+    ...platforms.length > 0 ? { platforms } : {},
+    waived: waivedOf(raw)
+  };
+}
+
+// src/commands/canvas/rule-gate.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+function tellLine(tell) {
+  const where = tell.kind === "forbidden" ? `"${tell.line ?? ""}" says "${tell.phrase}"` : `No line says "${tell.phrase}"`;
+  const words = tell.quote ? ` Their words: ${tell.quote}` : "";
+  return `${where}: ${tell.rule} (${tell.strength}) \u2014 ${tell.text}${words}`;
+}
+function ruleRefusal(tells) {
+  if (tells.length === 0) return null;
+  return {
+    problems: [...new Set(tells.map(tellLine))],
+    fix: 'Rewrite each line named above within its rule (a static: its `copy` in prompt.json; a video: its scene files and ad.spec.json), then re-run. Only when the person explicitly asked for these words in this ad, keep them and add to prompt.json `"waive": [{"rule": "<id>", "why": "<their ask>"}]`.'
+  };
+}
+var liveRoster = () => readAvatars("/api/avatars", { status: "ready" }).then(avatarsOf, () => null);
+async function heldRules(creativeDir, ad) {
+  const words = ad === void 0 ? await readAdWords(creativeDir) : ad;
+  const root = findWorkspaceRoot(creativeDir) ?? workspaceOfCreative(creativeDir);
+  const context = await readCreativeContext(
+    root,
+    {
+      ...words ? { kind: words.kind } : {},
+      ...words?.product ? { product: words.product } : {},
+      ...words?.platform ? { platform: words.platform } : {},
+      ...words?.platforms ? { platforms: words.platforms } : {}
+    },
+    { waived: words?.waived ?? [] }
+  );
+  const language = words?.language ?? marketFromCompanyDoc(await readFile2(path2.join(root, "COMPANY.md"), "utf8").catch(() => null))?.language;
+  return { rules: context.rules, ...language ? { language } : {} };
+}
+async function ruleGate(creativeDir, roster = liveRoster) {
+  const ad = await readAdWords(creativeDir);
+  if (!ad) return { broken: null, realOnly: null };
+  const { rules, language } = await heldRules(creativeDir, ad);
+  const people = rules.find((r) => r.check?.people === "real" && r.strength !== "prefer");
+  return {
+    broken: ruleRefusal(ruleTells(ad.lines, rules, language)),
+    realOnly: people ? {
+      rule: { id: people.id, text: people.text, ...people.source.quote ? { quote: people.source.quote } : {} },
+      avatars: await roster().catch(() => null)
+    } : null
+  };
+}
+
+export {
+  readAdWords,
+  ruleRefusal,
+  heldRules,
+  ruleGate
+};
+//# sourceMappingURL=chunk-TG4NCHFS.js.map

package/dist/chunk-TTHM66TA.js

@@ -0,0 +1,207 @@
+import {
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson
+} from "./chunk-SWL4AAPP.js";
+import {
+  LINKEDIN_SEARCH_STATUSES,
+  unsupportedLinkedinSearchStatuses
+} from "./chunk-DAO63OOP.js";
+import {
+  ApiError
+} from "./chunk-XDZVBX6L.js";
+import {
+  MissingChatIdError,
+  getEnv
+} from "./chunk-EE72SSB2.js";
+
+// src/commands/ads/linkedin/shared.ts
+import { readFileSync } from "fs";
+var DAY_MS = 864e5;
+function handleLinkedinError(err) {
+  if (err instanceof ApiError) {
+    if (needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("linkedin_ads", err.message);
+    }
+    if (isNoAccountsSelectedError(err.code, err.message)) {
+      handleConnectionError("linkedin_ads", err.message);
+    }
+    const explanation = explainLinkedinError(err);
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: explanation.action,
+          explanation: explanation.message,
+          correctedCommand: explanation.correctedCommand
+        },
+        retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE" || err.code === "INTERNAL_ERROR"
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  writeAdsJson(unexpectedErrorEnvelope(err));
+  process.exit(1);
+}
+function unexpectedErrorEnvelope(err) {
+  if (err instanceof MissingChatIdError) {
+    return {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: "reject",
+          explanation: "LinkedIn changes are staged in a chat and this run has none. Don't retry: carry on with the rest of the job and tell the user this change couldn't be staged from here."
+        },
+        retryable: false
+      }
+    };
+  }
+  const message = err instanceof Error ? err.message : "Unexpected error";
+  return { ok: false, error: { code: "NETWORK_ERROR", message } };
+}
+function isNoAccountsSelectedError(code, message) {
+  return code === "VALIDATION_ERROR" && /no linkedin ad accounts selected/i.test(message);
+}
+function explainLinkedinError(err) {
+  const lower = err.message.toLowerCase();
+  if (err.code === "VALIDATION_ERROR" && lower.includes("granularity") && lower.includes("daily")) {
+    return {
+      action: "retry_with_flag",
+      message: "LinkedIn rejects DAILY granularity when pivoting on demographic dims (job-title, company, etc.). Re-run with --granularity ALL or MONTHLY.",
+      correctedCommand: void 0
+    };
+  }
+  if (err.code === "RATE_LIMITED") {
+    return {
+      action: "wait_and_retry",
+      message: "Hit a LinkedIn throttle. The CLI already backs off automatically \u2014 if you see this you've exhausted the retry budget. Wait ~60s and retry."
+    };
+  }
+  if (err.code === "INTERNAL_ERROR" && lower.includes("deprecat")) {
+    return {
+      action: "reject",
+      message: "LinkedIn-Version header is deprecated. The backend constant LINKEDIN_API_VERSION needs to be bumped \u2014 file an issue or update the constant."
+    };
+  }
+  return { action: "reject", message: err.message };
+}
+var LI_ACCOUNT_ID_RE = /^(urn:li:sponsoredAccount:)?\d+$/;
+function resolveAccountIdArg(args) {
+  const fromArgs = args["account-id"] ?? args["account-urn"];
+  const id = fromArgs || getEnv().BAKER_LINKEDIN_AD_ACCOUNT_ID;
+  if (!id) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MISSING_ACCOUNT_ID",
+        message: "Pass --account-id (numeric) or --account-urn (urn:li:sponsoredAccount:N), or set BAKER_LINKEDIN_AD_ACCOUNT_ID. Run `baker ads linkedin accounts` to find IDs."
+      }
+    });
+    process.exit(1);
+  }
+  if (!LI_ACCOUNT_ID_RE.test(id)) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: `Invalid LinkedIn account ID "${id}". Expected numeric or urn:li:sponsoredAccount:N.`
+      }
+    });
+    process.exit(1);
+  }
+  return id.startsWith("urn:") ? id.split(":").pop() ?? id : id;
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function daysAgoIso(days) {
+  return new Date(Date.now() - days * DAY_MS).toISOString().slice(0, 10);
+}
+function csvOrJson(args) {
+  return args.output ?? "json";
+}
+function statusesArgDescription(level) {
+  return `CSV of statuses (${LINKEDIN_SEARCH_STATUSES[level].join(",")})`;
+}
+function statusFilterError(level, statuses) {
+  const unsupported = unsupportedLinkedinSearchStatuses(level, statuses);
+  if (unsupported.length === 0) {
+    return null;
+  }
+  const accepted = LINKEDIN_SEARCH_STATUSES[level].join(",");
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_STATUS",
+      message: `LinkedIn does not accept status ${unsupported.join(", ")} for this listing.`,
+      fix: {
+        action: "retry_with_flag",
+        explanation: `Re-run with --statuses from ${accepted}, or --all-statuses to drop the filter.`
+      },
+      retryable: false
+    }
+  };
+}
+function resolveStatusFilter(args, level) {
+  if (args["all-statuses"]) {
+    return void 0;
+  }
+  const explicit = args.statuses;
+  if (!explicit) {
+    return ["ACTIVE"];
+  }
+  const statuses = explicit.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+  const error = statusFilterError(level, statuses);
+  if (error) {
+    writeAdsJson(error);
+    process.exit(1);
+  }
+  return statuses;
+}
+function loadTargetingArg(args) {
+  const inline = args.targeting;
+  if (inline) {
+    try {
+      return JSON.parse(inline);
+    } catch {
+      handleLinkedinError(new Error("--targeting must be valid JSON. See LinkedIn 'targetingCriteria' shape."));
+    }
+  }
+  const file = args["targeting-file"];
+  if (file) {
+    try {
+      return JSON.parse(readFileSync(file, "utf-8"));
+    } catch (e) {
+      handleLinkedinError(
+        new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
+      );
+    }
+  }
+  handleLinkedinError(new Error("Pass --targeting-file <path> or --targeting '{...JSON...}'"));
+}
+function exitOnInvalidArgs(issues, flagByField) {
+  const messages = issues.map((issue) => {
+    const field = String(issue.path[0] ?? "");
+    return `${flagByField[field] ?? (field || "args")}: ${issue.message}`;
+  });
+  writeAdsJson({ ok: false, error: { code: "INVALID_ARGS", message: messages.join("; ") } });
+  process.exit(1);
+}
+
+export {
+  handleLinkedinError,
+  resolveAccountIdArg,
+  todayIso,
+  daysAgoIso,
+  csvOrJson,
+  statusesArgDescription,
+  resolveStatusFilter,
+  loadTargetingArg,
+  exitOnInvalidArgs
+};
+//# sourceMappingURL=chunk-TTHM66TA.js.map

package/dist/chunk-VL2GNXZY.js

@@ -0,0 +1,19 @@
+import {
+  latestVersion
+} from "./chunk-ZEPUDYPL.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-23H4ZJRP.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-VL2GNXZY.js.map

package/dist/chunk-VQPZDM6N.js

@@ -0,0 +1,160 @@
+import {
+  coverageOf,
+  readCreativeRecords,
+  readIdeas,
+  readInsights,
+  readKnowledgeCorpus,
+  readPersonaIds,
+  sameMessageRead,
+  workspaceIdeasJudge
+} from "./chunk-EOY6BK4C.js";
+import {
+  readAllRules
+} from "./chunk-SGEPZB3D.js";
+import {
+  IDEA_ANGLES,
+  IDEA_FORMATS,
+  checkIdeas
+} from "./chunk-G2LGMWNG.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-23H4ZJRP.js";
+import {
+  selectRules
+} from "./chunk-IKCP5NCE.js";
+import {
+  marketFromCompanyDoc
+} from "./chunk-2WZI36D3.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-WNSE7N75.js";
+
+// src/commands/creatives/ideas.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+var BUILD_NEXT = 3;
+var DESCRIPTION = `Check and rank the ad ideas in src/creatives/_ideas/: is each backed by something a customer said (src/content/insights/), does it claim only what the Knowledge holds, is it a different ad from the others, does it fill a gap the live ads leave. Free and local.
+
+Start here, after writing 4-8 idea files (one per file: who, message, evidence, awareness, angle, shows, job, why; format only for a video or a container the person asked for):
+  baker creatives ideas            # ranked, with problems; build_next names the ones to make
+  baker creatives make <idea>      # then build each one in build_next
+An idea with a problem is not built until it is fixed. An idea with no evidence is an explore bet: it may be built, and says so.`;
+var ARGS = {
+  full: {
+    type: "boolean",
+    description: "Every idea with its warnings and gaps, and the allowed angle and format values",
+    required: false,
+    default: false
+  }
+};
+registerSchema({ command: "creatives.ideas", description: DESCRIPTION, args: ARGS });
+function ideasHints(report) {
+  const hints = [];
+  const toBuild = report.ideas.filter((i) => i.status === "idea");
+  if (toBuild.length === 0 && report.unreadable.length === 0) {
+    hints.push(
+      "No ideas yet. Write 4-8 files in src/creatives/_ideas/<idea>.md (who, message, evidence, awareness, angle, shows, job, why), then run this again."
+    );
+  }
+  if (report.unreadable.length > 0) {
+    hints.push(`Fix ${report.unreadable.map((u) => u.id).join(", ")}: each names what is missing or unknown.`);
+  }
+  const blocked = toBuild.filter((i) => i.problems.length > 0);
+  if (blocked.length > 0) hints.push(`Fix before building: ${blocked.map((i) => i.id).join(", ")}.`);
+  if (report.observedCount < 3) {
+    hints.push(
+      "Few customer quotes on file: run `baker research customers` so ideas stand on what customers said; until then they are explore bets."
+    );
+  } else if (toBuild.length > 0 && toBuild.every((i) => i.evidence === "explore")) {
+    hints.push("No idea cites an insight: put the insight ids that back each one in its `evidence`.");
+  }
+  const next = buildNext(report.ideas);
+  if (next.length === 1) hints.push(`Build: \`baker creatives make ${next[0]}\`.`);
+  if (next.length > 1)
+    hints.push(
+      `Build ${next.join(", ")} at once: one \`creative-producer\` per idea, all spawned in one message in the background, each given its idea id, and handle each as it returns. Never build them one after another: each render takes minutes. Edited an idea after this check? Run \`baker creatives ideas\` again first: a producer cannot build an idea with a problem.`
+    );
+  return hints;
+}
+function buildNext(ideas, count = BUILD_NEXT) {
+  const ready = ideas.filter((i) => i.status === "idea" && i.problems.length === 0);
+  const firstBet = ready.find((i) => i.evidence === "explore");
+  return ready.filter((i) => i.evidence !== "explore" || i === firstBet).slice(0, count).map((i) => i.id);
+}
+function compactIdea(check) {
+  return {
+    idea: check.id,
+    status: check.status,
+    evidence: check.evidence,
+    ...check.quote ? { quote: check.quote.length > 120 ? `${check.quote.slice(0, 117)}...` : check.quote } : {},
+    awareness: check.awareness,
+    angle: check.angle,
+    ...check.shows ? { shows: check.shows } : {},
+    ...check.format ? { format: check.format } : {},
+    platforms: check.platforms ?? "unset",
+    ...check.problems.length > 0 ? { problems: check.problems } : {},
+    ...check.warnings.length > 0 ? { warnings: check.warnings } : {}
+  };
+}
+async function ideasReport(root, opts = {}) {
+  const judge = opts.ask ? { ask: opts.ask, done: () => Promise.resolve() } : workspaceIdeasJudge(root);
+  const [{ ideas, unreadable }, insights, knowledge, personas, creatives, rules, companyDoc] = await Promise.all([
+    readIdeas(root),
+    readInsights(root, { ask: judge.ask }),
+    readKnowledgeCorpus(root),
+    readPersonaIds(root),
+    readCreativeRecords(root),
+    readAllRules(root).then((all) => selectRules(all, {})),
+    readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => null)
+  ]);
+  const language = marketFromCompanyDoc(companyDoc)?.language;
+  const sameMessage = await sameMessageRead(ideas, judge.ask);
+  await judge.done();
+  const checked = checkIdeas({
+    ideas,
+    insights,
+    knowledge,
+    personas,
+    sameMessage,
+    rules,
+    ...language ? { language } : {},
+    ...coverageOf(ideas, creatives)
+  });
+  return {
+    ideas: checked,
+    unreadable,
+    insightCount: insights.length,
+    observedCount: insights.filter((i) => i.status === "observed").length
+  };
+}
+var ideasCommand = defineCommand({
+  meta: { name: "ideas", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const report = await ideasReport(root);
+    const full = args.full === true;
+    writeJson({
+      ok: true,
+      data: {
+        build_next: buildNext(report.ideas),
+        ideas: full ? report.ideas : report.ideas.map(compactIdea),
+        ...report.unreadable.length > 0 ? { unreadable: report.unreadable } : {},
+        customer_quotes: { total: report.insightCount, observed: report.observedCount },
+        ...full ? { allowed: { angle: IDEA_ANGLES, format: IDEA_FORMATS } } : {}
+      },
+      hints: ideasHints(report)
+    });
+  }
+});
+
+export {
+  ideasHints,
+  buildNext,
+  compactIdea,
+  ideasReport,
+  ideasCommand
+};
+//# sourceMappingURL=chunk-VQPZDM6N.js.map

package/dist/chunk-XCKINS7K.js

@@ -0,0 +1,57 @@
+import {
+  formEventKey
+} from "./chunk-BC2BXRXY.js";
+import {
+  flowNodeTriggers
+} from "./chunk-DAO63OOP.js";
+
+// ../api/src/analytics/flowEventKeys.ts
+function flowNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  const record = node;
+  acc.push(record);
+  if (Array.isArray(record.children)) for (const child of record.children) flowNodes(child, acc);
+  return acc;
+}
+function flowEventKeys(tree, slug) {
+  const primary = [];
+  const secondary = [];
+  const nodes = flowNodes(tree).filter((node) => typeof node.id === "string" && node.id !== "");
+  if (nodes.length === 0) return [];
+  for (const node of nodes) {
+    const id = node.id;
+    const triggers = flowNodeTriggers(node.nodeData);
+    for (const triggerId of triggers.available) {
+      const candidate = {
+        eventKey: formEventKey(slug, id, triggerId),
+        nodeId: id,
+        nodeName: typeof node.name === "string" ? node.name : id,
+        nodeType: triggers.type,
+        triggerId,
+        isCompletion: triggers.completion === triggerId
+      };
+      (candidate.isCompletion ? primary : secondary).push(candidate);
+    }
+  }
+  return [
+    ...primary,
+    ...secondary,
+    {
+      eventKey: `submit:${slug}`,
+      nodeId: null,
+      nodeName: "the Form ran out of steps",
+      nodeType: null,
+      triggerId: null,
+      // A Form reaching its last node is as primary as an outcome gets for a
+      // Form with no widget in it — but it never fires on one that ends in a
+      // booking widget or a redirect, so it does not lead the list.
+      isCompletion: false
+    }
+  ];
+}
+
+export {
+  flowNodes,
+  flowEventKeys
+};
+//# sourceMappingURL=chunk-XCKINS7K.js.map