@koda-sl/baker-cli 0.524.0-dev.3eb5500a1 → 0.525.0

package/dist/chunk-33WJWY36.js

@@ -0,0 +1,106 @@
+import {
+  apiGet
+} from "./chunk-DPPV45D5.js";
+
+// src/commands/testimonials/emptyCorpusHints.ts
+function resolveEmptyReason({
+  resultCount,
+  activeFilters,
+  sourceCount
+}) {
+  if (resultCount > 0) {
+    return null;
+  }
+  if (activeFilters.length > 0) {
+    return "filtered_out";
+  }
+  return sourceCount === 0 ? "no_corpus_connected" : "corpus_empty";
+}
+var NO_CORPUS_EXIT = "Testimonials are ingested from the client's public review pages \u2014 an agent cannot write one \u2014 so no rewording will find quotes. If the user named the client's own review page (Google Maps, Trustpilot, Yelp, Tripadvisor, G2, Capterra, Amazon, App Store, Google Play), add it with `baker testimonials sources add <link>` \u2014 its reviews arrive over the next minutes, not in this turn. Stop searching and source proof another way: a result or case study the client already published, a named-customer logo (`baker images logo`), or a founder claim attributed as a claim. Otherwise ship without a testimonial block and file the gap: `baker actions create --name \"Collect customer quotes for <page>\" --priority medium --tags <slug>`. Never invent, paraphrase-into-existence, or pad with unrelated praise.";
+function emptyReasonDetail(reason, sourceCount, activeFilters) {
+  if (reason === "filtered_out") {
+    return `No rows matched, and ${activeFilters.join(", ")} narrowed this read. The corpus was not checked \u2014 drop every filter to see whether the library itself is empty.`;
+  }
+  if (reason === "no_corpus_connected") {
+    return "This company has no review source connected \u2014 checked against its source list, not inferred from the empty result.";
+  }
+  return `${sourceCount} review source${sourceCount === 1 ? " is" : "s are"} connected but hold no testimonials yet \u2014 the source is there, the rows are not. Ingestion may still be running.`;
+}
+function morePagesHint(resultCount, cursor) {
+  const found = resultCount === 0 ? "This page held no matches" : `This page held ${resultCount}`;
+  return `${found}, and the library continues past it \u2014 so this is one page, not the client's whole set. Do not report it as the corpus and do not conclude anything is missing from it. Read the next page with \`baker testimonials list --cursor ${cursor}\` (same filters), or go straight at the rows you want with \`baker testimonials search <query>\`.`;
+}
+function endOfWalkHint(command) {
+  const noun = command === "search" ? "results" : "rows";
+  return `That was the end of the library \u2014 no more ${noun} past the page before this one. Nothing here says the corpus is empty (the earlier pages held it), so answer from what those pages returned rather than re-reading.`;
+}
+async function measureEmptyCorpus({
+  command,
+  resultCount,
+  activeFilters,
+  nextCursor = null,
+  continued = false
+}) {
+  if (nextCursor) {
+    return { hints: [morePagesHint(resultCount, nextCursor)] };
+  }
+  if (resultCount > 0) {
+    return { hints: [] };
+  }
+  if (continued) {
+    return { hints: [endOfWalkHint(command)] };
+  }
+  if (activeFilters.length > 0) {
+    const reason2 = "filtered_out";
+    return {
+      hints: emptyCorpusHints({ command, reason: reason2, sourceCount: 0, activeFilters }),
+      empty: { reason: reason2, detail: emptyReasonDetail(reason2, 0, activeFilters) }
+    };
+  }
+  let sourceCount;
+  try {
+    const sources = await apiGet("/api/testimonials/sources");
+    sourceCount = Array.isArray(sources) ? sources.length : 0;
+  } catch {
+    return {
+      hints: [
+        "No rows, and the check for connected review sources failed \u2014 so this is NOT evidence that the client has no reviews. Do not record an absence you could not verify. Re-run once; if it fails again, say the library could not be read rather than that it is empty."
+      ]
+    };
+  }
+  const reason = resolveEmptyReason({ resultCount, activeFilters, sourceCount });
+  if (reason === null) {
+    return { hints: [] };
+  }
+  return {
+    hints: emptyCorpusHints({ command, reason, sourceCount, activeFilters }),
+    empty: { reason, detail: emptyReasonDetail(reason, sourceCount, activeFilters) }
+  };
+}
+function emptyCorpusHints({
+  command,
+  reason,
+  sourceCount,
+  activeFilters
+}) {
+  if (reason === null) {
+    return [];
+  }
+  if (reason === "filtered_out") {
+    return [
+      `No rows \u2014 ${activeFilters.join(", ")} narrowed this. Drop every filter and re-run once before touching the query; a filter combination and an empty library look identical from here.`
+    ];
+  }
+  const lead = command === "search" ? "No hits" : "No rows";
+  if (reason === "no_corpus_connected") {
+    return [`${lead}, and this company's source list is empty: there is no review corpus to search. ${NO_CORPUS_EXIT}`];
+  }
+  return [
+    `${lead}. ${sourceCount} review source${sourceCount === 1 ? " is" : "s are"} connected but no testimonials have landed yet \u2014 so this is a timing or ingestion gap, not a missing connection, and re-querying will not change it. Ingestion may still be running: say so rather than reporting the client has no reviews. ${NO_CORPUS_EXIT}`
+  ];
+}
+
+export {
+  measureEmptyCorpus
+};
+//# sourceMappingURL=chunk-33WJWY36.js.map

package/dist/chunk-3662ESC7.js

@@ -0,0 +1,58 @@
+import {
+  readAvatars
+} from "./chunk-XZLGG2AT.js";
+
+// src/commands/canvas/scaffold-static-ad-paths.ts
+import path from "path";
+function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
+  const file = rawFile.trim();
+  const imageIsUrl = /^https?:\/\//i.test(file);
+  const imageSource = imageIsUrl ? file : path.resolve(cwd, file);
+  const outPath = out ? path.resolve(cwd, out) : slug ? path.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path.join(cwd, "static-ad.canvas.json") : path.join(path.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath = path.join(path.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path.join(creativeDir, "references") : null;
+  return { imageIsUrl, imageSource, outPath, blueprintPath, creativeDir, definitionPath, referencesDir };
+}
+var SCAFFOLD_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var SCAFFOLD_SLUG_MAX_LENGTH = 100;
+function isValidScaffoldSlug(slug) {
+  return slug.length <= SCAFFOLD_SLUG_MAX_LENGTH && SCAFFOLD_SLUG_PATTERN.test(slug);
+}
+
+// src/commands/avatars/resolveCast.ts
+async function resolveCastAvatar(handle) {
+  try {
+    const avatar = await readAvatars("/api/avatars/get", { handle });
+    if (avatar.status && avatar.status !== "ready") {
+      return {
+        error: `Avatar \`${handle}\` is ${avatar.status}, not ready \u2014 \`baker avatars get ${handle} --wait\` returns the moment it is.`
+      };
+    }
+    if (!avatar.sheetUrl)
+      return { error: `Avatar \`${handle}\` has no identity sheet yet, so the ad cannot ground on their face.` };
+    return { sheetUrl: avatar.sheetUrl, subjectDescription: avatar.subjectDescription, handle };
+  } catch (e) {
+    return {
+      error: `Could not read avatar \`${handle}\`: ${e instanceof Error ? e.message : String(e)}. \`baker avatars list\` shows who there is.`
+    };
+  }
+}
+async function resolveCastAvatars(flag) {
+  const handles = String(flag ?? "").split(",").map((h) => h.trim()).filter(Boolean);
+  const avatars = [];
+  for (const handle of handles) {
+    const resolved = await resolveCastAvatar(handle);
+    if ("error" in resolved) return resolved;
+    avatars.push(resolved);
+  }
+  return { handles, avatars };
+}
+
+export {
+  resolveScaffoldStaticAdPaths,
+  isValidScaffoldSlug,
+  resolveCastAvatars
+};
+//# sourceMappingURL=chunk-3662ESC7.js.map

package/dist/chunk-3N4SIGSG.js

@@ -0,0 +1,111 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-6JACV223.js";
+import {
+  apiGet
+} from "./chunk-DPPV45D5.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-UCI6ZGUF.js";
+
+// src/commands/winning-ads/launches.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.launches",
+  description: 'What the brands you follow (or the ones named) launched in the last N days and which of those ads still run, each with its stage (new, testing, killed_early\u2026), and the tests each brand decided in that window (the version kept, what differed). The "what did competitors launch last week" report. Compact by default; --full lists every launch.',
+  args: {
+    since: { type: "number", description: "Days to look back, 1-90 (default 7)", required: false, default: 7 },
+    advertiser: {
+      type: "string",
+      description: "Comma list of advertiser ids instead of every followed brand",
+      required: false
+    },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  }
+});
+var COMPACT_LAUNCHES = 10;
+function compactLaunches(report, full) {
+  return {
+    since_days: report.since_days,
+    advertisers: report.advertisers.map((b) => ({
+      advertiser_id: b.advertiser_id,
+      label: b.label,
+      launched: b.launched,
+      still_running: b.still_running,
+      launches: (full ? b.launches : b.launches.slice(0, COMPACT_LAUNCHES)).map((l) => ({
+        ad_id: l.ad_id,
+        platform: l.platform,
+        format: l.format,
+        headline: l.headline,
+        first_seen_at: l.first_seen_at,
+        stage: l.stage,
+        idea: l.idea ?? null,
+        ...full ? { media_url: l.media_url } : {}
+      })),
+      tests_decided: (b.tests_decided ?? []).map((t) => ({
+        concept: t.concept,
+        versions: t.versions,
+        kept_ad_id: t.winner_ad_id,
+        decided_at: t.decided_at ?? null,
+        what_differed: t.what_differed
+      }))
+    }))
+  };
+}
+var IDEA_HINT = "Idea: whether each launch was a `new` idea (the first day of its concept), another version of one the brand was still `testing`, or a version built on a `winner` it had already kept. Many launches and no new idea means the brand is iterating on what works, not testing new directions: say so.";
+function launchesHints(report, named) {
+  if (!named && report.following_count === 0) {
+    return ["You follow no brands yet: `baker winning-ads follow <domain>` adds one, or pass --advertiser <id>."];
+  }
+  if (report.advertisers.length === 0) {
+    return [`No launches in the last ${report.since_days} days. Widen the window with --since 30.`];
+  }
+  const withIdeas = report.advertisers.some((b) => b.launches.some((l) => l.idea));
+  return [
+    ...withIdeas ? [IDEA_HINT] : [],
+    "Stages: new \u22647 days, testing \u226421 days, proven \u226460 days, evergreen beyond, killed_early = stopped within 2 weeks (a lost test). tests_decided is what each brand learned in the window: the version it kept (kept_ad_id) and what differed. `baker winning-ads search --survived-test` finds the versions brands kept across the library."
+  ];
+}
+var launchesCommand = defineCommand({
+  meta: {
+    name: "launches",
+    description: "What competitors launched lately and what still runs. Start here: baker winning-ads launches --since 7 (every followed brand), or --advertiser adv_1,adv_2"
+  },
+  args: {
+    since: { type: "string", description: "Days to look back, 1-90 (default 7)", required: false },
+    advertiser: { type: "string", description: "Comma list of advertiser ids", required: false },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const named = splitList(args.advertiser);
+      const params = { since_days: String(args.since ?? 7) };
+      if (named.length > 0) {
+        params.advertiser = named.join(",");
+      }
+      if (args.platform) {
+        params.platform = String(args.platform);
+      }
+      const report = await apiGet("/api/ad-library/launches", params);
+      writeJson({
+        ok: true,
+        data: compactLaunches(report, Boolean(args.full)),
+        hints: launchesHints(report, named.length > 0)
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+
+export {
+  compactLaunches,
+  IDEA_HINT,
+  launchesHints,
+  launchesCommand
+};
+//# sourceMappingURL=chunk-3N4SIGSG.js.map

package/dist/chunk-3VNW4CZF.js

@@ -0,0 +1,76 @@
+import {
+  MAX_REMOTE_IMAGE_BYTES,
+  fetchExternalBytes
+} from "./chunk-OMORXBRN.js";
+
+// src/lib/image/io.ts
+import { randomBytes } from "crypto";
+import { glob as fsGlob, readFile, rename, stat, writeFile } from "fs/promises";
+import { dirname, extname, join, resolve } from "path";
+var REMOTE_RE = /^https?:\/\//i;
+var GLOB_RE = /[*?[\]{}]/;
+function isRemoteUrl(value) {
+  return REMOTE_RE.test(value);
+}
+function looksLikeGlob(value) {
+  return GLOB_RE.test(value);
+}
+async function expandInputs(spec) {
+  const parts = spec.split(",").map((p) => p.trim()).filter(Boolean);
+  const out = [];
+  for (const part of parts) {
+    if (isRemoteUrl(part)) {
+      out.push(part);
+      continue;
+    }
+    if (looksLikeGlob(part)) {
+      for await (const match of fsGlob(part)) {
+        if (typeof match === "string") out.push(match);
+      }
+    } else {
+      out.push(part);
+    }
+  }
+  return out;
+}
+async function readImageBuffer(pathOrUrl) {
+  if (isRemoteUrl(pathOrUrl)) {
+    const { buffer } = await fetchExternalBytes(pathOrUrl, { maxBytes: MAX_REMOTE_IMAGE_BYTES });
+    return buffer;
+  }
+  return readFile(pathOrUrl);
+}
+async function isDirectory(path) {
+  try {
+    const s = await stat(path);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function resolveOutputPath(inputPath, outputArg, options) {
+  const base = options.newExtension ? inputPath.slice(0, -extname(inputPath).length) + options.newExtension : inputPath;
+  if (!outputArg) return base;
+  if (options.multipleInputs || await isDirectory(outputArg)) {
+    const filename = base.split("/").pop() ?? "out.png";
+    return join(outputArg, filename);
+  }
+  return outputArg;
+}
+async function atomicWrite(targetPath, data) {
+  const absolute = resolve(targetPath);
+  const dir = dirname(absolute);
+  const tmp = join(dir, `.baker-image-${randomBytes(8).toString("hex")}.tmp`);
+  await writeFile(tmp, data);
+  await rename(tmp, absolute);
+}
+
+export {
+  isRemoteUrl,
+  expandInputs,
+  readImageBuffer,
+  isDirectory,
+  resolveOutputPath,
+  atomicWrite
+};
+//# sourceMappingURL=chunk-3VNW4CZF.js.map

package/dist/chunk-42YZYRDP.js

@@ -0,0 +1,163 @@
+import {
+  failApi
+} from "./chunk-VFDV7VH3.js";
+import {
+  CREATIVE_PERFORMANCE_DEFAULT_DAYS,
+  CREATIVE_PERFORMANCE_MAX_DAYS
+} from "./chunk-HVJJEQDQ.js";
+import {
+  apiPost
+} from "./chunk-DPPV45D5.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-UCI6ZGUF.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 syncedCreativesHint(slug) {
+  return `Live Meta read. Across every platform, from the synced copy (no rate limit, full history): baker ads performance creatives ranks them against their ad-group peers (madeInBaker names this creative), and baker ads performance live-in --creative ${slug ?? "<slug>"} lists the live campaigns showing it.`;
+}
+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);
+      const out = withDefinitions(response, readLocalDefinition);
+      writeJson({ ...out, hints: [...out.hints ?? [], syncedCreativesHint(slug)] });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+
+export {
+  definitionInsights,
+  withDefinitions,
+  parseDays,
+  performanceCommand
+};
+//# sourceMappingURL=chunk-42YZYRDP.js.map