@koda-sl/baker-cli 0.572.0 → 0.574.0

package/dist/chunk-XMIV53FM.js

@@ -0,0 +1,191 @@
+import {
+  hintLines,
+  splitHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  isNotConnectedError,
+  writeJsonEnvelope
+} from "./chunk-VJUVTMHY.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-OMLZ35HJ.js";
+
+// src/commands/ga4/shared.ts
+import { readFileSync } from "fs";
+function failValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function requireTarget(args, entity) {
+  const positional = Array.isArray(args._) ? args._[0] : void 0;
+  const target = args.id ?? args.target ?? positional;
+  if (typeof target !== "string" || target.length === 0) {
+    failValidation(`pass the ${entity} id as the positional argument`);
+  }
+  return target;
+}
+function readJsonSource(args, flag) {
+  const inline = args[flag];
+  const file = args.file;
+  const raw = typeof file === "string" && file.length > 0 ? readFileSync(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
+  if (raw === void 0) {
+    failValidation(`pass --${flag} with inline JSON or --file with a path to a JSON file`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return failValidation(`--${flag} is not valid JSON`);
+  }
+}
+function asObject(value, flag, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    failValidation(
+      index === void 0 ? `--${flag} must be a JSON object` : `--${flag}[${index}] must be a JSON object`
+    );
+  }
+  return value;
+}
+function loadJsonArg(args, flag = "json") {
+  return asObject(readJsonSource(args, flag), flag);
+}
+function loadJsonPayloads(args) {
+  const parsed = readJsonSource(args, "json");
+  if (!Array.isArray(parsed)) {
+    return [asObject(parsed, "json")];
+  }
+  if (parsed.length === 0) {
+    failValidation("--json is an empty list \u2014 pass at least one definition");
+  }
+  return parsed.map((entry, index) => asObject(entry, "json", index));
+}
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["RATE_LIMITED", "UNAVAILABLE", "INTERNAL_ERROR", "NETWORK_ERROR", "TIMEOUT"]);
+function handleError(err) {
+  if (err instanceof ApiError) {
+    const readOnly = err.code === "FORBIDDEN" && /read the property but not change it/i.test(err.message);
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        ...readOnly ? {
+          fix: {
+            action: "reconnect",
+            explanation: "The Google Analytics connection is read-only. Ask the user to reconnect Google Analytics \u2014 in the dashboard, Brain \u2192 Integrations \u2192 Platforms \u2192 Google Analytics \u2014 which grants the permission to change the property. Reporting (`baker ga4 query`, `baker ga4 audit`) keeps working meanwhile, so carry on with the rest of the job and tell them what you will set up once they have reconnected. Don't claim anything was configured."
+          }
+        } : err.code === "UNAUTHORIZED" || err.code === "FORBIDDEN" && isNotConnectedError(err.code, err.message) ? {
+          fix: {
+            action: "request_connection",
+            explanation: 'Google Analytics is not connected for this company yet, or no property has been picked. Don\'t send the user to Settings \u2014 call the `request_connection` tool with { platform: "google-analytics", reason } and they connect and pick their property from inside the chat. If the `request_connection` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 Google Analytics. Then carry on with the rest of the task.'
+          }
+        } : {},
+        retryable: RETRYABLE_CODES.has(err.code)
+      }
+    });
+    process.exit(1);
+  }
+  writeJsonEnvelope({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error", retryable: true } });
+  process.exit(1);
+}
+var STAGE_HINTS = [
+  "Staged only \u2014 nothing has changed in Google Analytics yet. These apply when the chat completes, and an applied change takes effect on the property immediately: there is no version to publish afterwards and no undo. Say the changes are ready and take effect when the user completes the chat \u2014 not that they are done already."
+];
+var WARNING_HINT = "Read the warnings above before telling the user this is ready.";
+async function stageOp(op) {
+  const chatId = requireChatId();
+  try {
+    const { data, hints } = splitHints(await apiPost("/api/ga4/draft/stage", { chatId, op }));
+    writeJsonEnvelope({
+      ok: true,
+      data,
+      hints: [...hints, ...STAGE_HINTS, ...data.warnings.length > 0 ? [WARNING_HINT] : []]
+    });
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function stageOps(ops) {
+  const [only] = ops;
+  if (ops.length === 1 && only) {
+    await stageOp(only);
+    return;
+  }
+  const chatId = requireChatId();
+  try {
+    const { data, hints } = splitHints(
+      await apiPost("/api/ga4/draft/stage-batch", { chatId, ops })
+    );
+    writeJsonEnvelope({
+      ok: true,
+      data,
+      hints: [...hints, ...STAGE_HINTS, ...data.ops.some((op) => op.warnings.length > 0) ? [WARNING_HINT] : []]
+    });
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function draftAction(path, body, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const { data, hints } = splitHints(await apiPost(path, { chatId, ...body }));
+    writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+    return data;
+  } catch (err) {
+    handleError(err);
+  }
+}
+function renderDraft(response) {
+  if (response.count === 0) {
+    return "No Google Analytics changes staged on this chat.";
+  }
+  const lines = [
+    response.status === "discarded" ? `${response.count} Google Analytics change(s) discarded with their chat \u2014 none will apply` : `${response.count} staged Google Analytics change(s)`,
+    ...response.ops.map((op) => {
+      const status = op.result ? ` [${op.result.status}]` : "";
+      return `  ${op.ref}  ${op.summary}${status}`;
+    })
+  ];
+  if (response.status === "applied") {
+    const failed = response.ops.filter((op) => op.result?.status !== "applied");
+    lines.push(
+      "",
+      failed.length === 0 ? "All applied \u2014 these are in effect on the property now." : `${failed.length} of ${response.count} did not apply. The rest are in effect on the property.`
+    );
+  }
+  if (response.publishError) {
+    lines.push("", response.publishError);
+  }
+  return lines.join("\n");
+}
+async function draftList(json, chat, full = false) {
+  const chatId = resolveChatId(chat);
+  try {
+    const response = await apiPost("/api/ga4/draft", { chatId, ...full ? { full: true } : {} });
+    const { data, hints } = splitHints(response);
+    if (json || full) {
+      writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+      return;
+    }
+    process.stdout.write(`${renderDraft(data)}${hintLines(response)}
+`);
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+export {
+  failValidation,
+  requireTarget,
+  loadJsonArg,
+  loadJsonPayloads,
+  handleError,
+  stageOp,
+  stageOps,
+  draftAction,
+  draftList
+};
+//# sourceMappingURL=chunk-XMIV53FM.js.map

package/dist/chunk-XNUUEUJB.js

@@ -0,0 +1,287 @@
+import {
+  failWriteValidation,
+  parseDateFlag,
+  parseMoneyFlag
+} from "./chunk-WFTTF2MP.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+
+// src/commands/ads/meta/delivery-flags.ts
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function frequencyCapFlag(value) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const match = /^(\d+)\s*\/\s*(\d+)\s*d?$/i.exec(raw.trim());
+  if (!match) {
+    failWriteValidation(
+      `--frequency-cap takes N/D \u2014 at most N impressions per person every D days, e.g. 2/7 (got "${raw}")`
+    );
+  }
+  return [{ event: "IMPRESSIONS", interval_days: Number(match[2]), max_frequency: Number(match[1]) }];
+}
+var DAY_INDEX = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+function dayIndex(name, flag) {
+  const index = DAY_INDEX[name.slice(0, 3).toLowerCase()];
+  if (index === void 0) {
+    failWriteValidation(`${flag}: "${name}" is not a day \u2014 use Mon, Tue, \u2026 Sun`);
+  }
+  return index;
+}
+function scheduleDays(spec) {
+  if (/^(daily|every ?day|all)$/i.test(spec)) {
+    return [0, 1, 2, 3, 4, 5, 6];
+  }
+  return spec.split(",").flatMap((part) => {
+    const [from, to] = part.split("-").map((day) => day.trim());
+    if (!from) {
+      return [];
+    }
+    const start = dayIndex(from, "--schedule");
+    if (!to) {
+      return [start];
+    }
+    const end = dayIndex(to, "--schedule");
+    const days = [];
+    for (let day = start; days.length < 7; day = (day + 1) % 7) {
+      days.push(day);
+      if (day === end) break;
+    }
+    return days;
+  });
+}
+function hourMinute(value) {
+  const [hours = "", minutes = "0"] = value.split(":");
+  return Number(hours) * 60 + Number(minutes);
+}
+function scheduleBlock(raw, timezone) {
+  const match = /^(.+?)\s+(\d{1,2}(?::\d{2})?)\s*-\s*(\d{1,2}(?::\d{2})?)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--schedule takes "<days> <from>-<to>", e.g. "Mon-Fri 09-18" or "sat,sun 10:00-14:00" (got "${raw}")`
+    );
+  }
+  return {
+    days: scheduleDays(match[1]),
+    start_minute: hourMinute(match[2]),
+    end_minute: hourMinute(match[3]),
+    timezone_type: timezone
+  };
+}
+function dayPartingFromFlags(args, rawArgs) {
+  const blocks = repeatedValues(rawArgs, "schedule", args.schedule).map((block) => {
+    const { timezone_type: _clock, ...rest } = scheduleBlock(block, "USER");
+    return rest;
+  });
+  return blocks.length > 0 ? blocks : void 0;
+}
+function scheduleTimezone(value) {
+  const raw = text(value)?.toLowerCase();
+  if (raw === void 0 || raw === "viewer" || raw === "user") {
+    return "USER";
+  }
+  if (raw === "account" || raw === "advertiser") {
+    return "ADVERTISER";
+  }
+  failWriteValidation(`--schedule-timezone takes viewer or account (got "${raw}")`);
+}
+var ATTRIBUTION_EVENTS = {
+  click: "CLICK_THROUGH",
+  view: "VIEW_THROUGH",
+  engaged_view: "ENGAGED_VIDEO_VIEW",
+  engaged_video_view: "ENGAGED_VIDEO_VIEW"
+};
+function attributionFlag(value) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  return raw.split(",").map((window) => {
+    const match = /^(\d+)d_([a-z_]+)$/i.exec(window.trim());
+    const event = match?.[2] ? ATTRIBUTION_EVENTS[match[2].toLowerCase()] : void 0;
+    if (!match || !event) {
+      failWriteValidation(`--attribution takes windows like 7d_click,1d_view,1d_engaged_view (got "${window}")`);
+    }
+    return { event_type: event, window_days: Number(match[1]) };
+  });
+}
+function numberArg(value, flag) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    failWriteValidation(`${flag} must be a number`);
+  }
+  return n;
+}
+function adSetDeliveryFromFlags(args, rawArgs) {
+  const timezone = scheduleTimezone(args["schedule-timezone"]);
+  const blocks = repeatedValues(rawArgs, "schedule", args.schedule).map((block) => scheduleBlock(block, timezone));
+  if (args["schedule-timezone"] !== void 0 && blocks.length === 0) {
+    failWriteValidation(
+      "--schedule-timezone says whose clock --schedule follows, so it goes with --schedule \u2014 pass the hours again with it"
+    );
+  }
+  const delivery = {
+    minRoas: numberArg(args["min-roas"], "--min-roas"),
+    frequency_control_specs: frequencyCapFlag(args["frequency-cap"]),
+    adset_schedule: blocks.length > 0 ? blocks : void 0,
+    pacing: text(args.pacing)?.toLowerCase(),
+    dailyMinSpendTarget: parseMoneyFlag(args["daily-min-spend"], args.currency, "--daily-min-spend"),
+    dailySpendCap: parseMoneyFlag(args["daily-spend-cap"], args.currency, "--daily-spend-cap"),
+    lifetimeMinSpendTarget: parseMoneyFlag(args["lifetime-min-spend"], args.currency, "--lifetime-min-spend"),
+    lifetimeSpendCap: parseMoneyFlag(args["lifetime-spend-cap"], args.currency, "--lifetime-spend-cap"),
+    is_dynamic_creative: args["dynamic-creative"] === void 0 ? void 0 : Boolean(args["dynamic-creative"]),
+    attribution_spec: attributionFlag(args.attribution)
+  };
+  return Object.fromEntries(Object.entries(delivery).filter(([, value]) => value !== void 0));
+}
+function budgetBoost(raw, currency) {
+  const match = /^(.+?)\.\.(.+?)=\+?(\d+(?:\.\d{1,3})?)(%?)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--budget-boost takes START..END=+AMOUNT or START..END=+PERCENT%, e.g. 2027-11-27T00:00Z..2027-11-28T00:00Z=+50% (got "${raw}")`
+    );
+  }
+  const period = {
+    time_start: parseDateFlag(match[1], "--budget-boost start"),
+    time_end: parseDateFlag(match[2], "--budget-boost end")
+  };
+  return match[4] === "%" ? { ...period, increasePercent: Number(match[3]) } : { ...period, increase: parseMoneyFlag(match[3], currency, "--budget-boost") };
+}
+function budgetBoostsFromFlags(args, rawArgs) {
+  const boosts = repeatedValues(rawArgs, "budget-boost", args["budget-boost"]);
+  return boosts.length > 0 ? boosts.map((boost) => budgetBoost(boost, args.currency)) : void 0;
+}
+function boostMove(raw) {
+  const match = /^(\d+)=(.+?)\.\.(.+)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--move-boost takes ID=START..END, e.g. 1633135568548763=2027-11-27T06:00Z..2027-11-27T12:00Z (got "${raw}")`
+    );
+  }
+  return {
+    id: match[1],
+    time_start: parseDateFlag(match[2], "--move-boost start"),
+    time_end: parseDateFlag(match[3], "--move-boost end")
+  };
+}
+function boostEditsFromFlags(args, rawArgs) {
+  const removed = repeatedValues(rawArgs, "remove-boost", args["remove-boost"]).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+  const moved = repeatedValues(rawArgs, "move-boost", args["move-boost"]);
+  return {
+    ...removed.length > 0 ? { removeBoosts: removed } : {},
+    ...moved.length > 0 ? { moveBoosts: moved.map(boostMove) } : {}
+  };
+}
+var boostEditArgs = {
+  "remove-boost": {
+    type: "string",
+    description: "Take one budget boost away, by its id from `baker ads meta high-demand-periods --campaign-id <id>` \u2014 repeatable or comma-separated. The others stay."
+  },
+  "move-boost": {
+    type: "string",
+    description: "Move one budget boost to another window, keeping its raise: ID=START..END, repeatable, at least 3 hours, on quarter hours. Meta has no boost update, so publish adds the same raise on the new window, then deletes the old boost. Example: --move-boost 1633135568548763=2027-11-27T06:00Z..2027-11-27T12:00Z"
+  }
+};
+var adSetDeliveryArgs = {
+  "min-roas": {
+    type: "string",
+    description: "Minimum ROAS for LOWEST_COST_WITH_MIN_ROAS bidding, as a multiple of spend: 2.5 = 250%. Needs --optimization-goal VALUE. Under a min-ROAS campaign budget every ad set needs its own. Example: --bid-strategy LOWEST_COST_WITH_MIN_ROAS --min-roas 2.5"
+  },
+  "frequency-cap": {
+    type: "string",
+    description: "At most N impressions per person every D days, as N/D \u2014 REACH and THRUPLAY goals only. Example: --frequency-cap 2/7"
+  },
+  schedule: {
+    type: "string",
+    description: 'Run ads only in these hours (dayparting), repeatable: "<days> <from>-<to>", whole hours. Needs --lifetime-budget and --end. Example: --schedule "Mon-Fri 09-18" --schedule "Sat 10-14"'
+  },
+  "schedule-timezone": {
+    type: "string",
+    description: "Whose clock --schedule follows: viewer (default) or account"
+  },
+  pacing: {
+    type: "string",
+    description: "standard (default) | no_pacing (accelerated \u2014 spends as fast as it can; LOWEST_COST_WITH_BID_CAP only) | day_parting (set by --schedule)"
+  },
+  "daily-min-spend": {
+    type: "string",
+    description: "Ad set spend limit under a DAILY campaign budget: spend at least this per day (best effort)"
+  },
+  "daily-spend-cap": {
+    type: "string",
+    description: "Ad set spend limit under a DAILY campaign budget: spend at most this per day. Example: --daily-spend-cap 15"
+  },
+  "lifetime-min-spend": {
+    type: "string",
+    description: "Ad set spend limit under a LIFETIME campaign budget: spend at least this in total"
+  },
+  "lifetime-spend-cap": {
+    type: "string",
+    description: "Ad set spend limit under a LIFETIME campaign budget: spend at most this in total"
+  },
+  attribution: {
+    type: "string",
+    description: "Attribution windows Meta optimizes on: 1d_click or 7d_click, plus 1d_view and/or 1d_engaged_view \u2014 conversion goals only; LINK_CLICKS, LANDING_PAGE_VIEWS and REACH take 1d_click alone. Fixed when the ad set is created: Meta refuses a change on a live ad set. Example: --attribution 7d_click,1d_view"
+  }
+};
+var budgetBoostArg = {
+  "budget-boost": {
+    type: "string",
+    description: "Raise the daily budget for a high-demand period, repeatable: START..END=+AMOUNT or START..END=+PERCENT% (max 800%), at least 3 hours, on quarter hours, all amounts or all percentages. Needs --daily-budget in the same command (the current one, on update). Example: --budget-boost 2027-11-27T00:00Z..2027-11-28T00:00Z=+50%"
+  }
+};
+var CLEAR_FLAGS = {
+  "daily-min-spend": "dailyMinSpendTarget",
+  "daily-spend-cap": "dailySpendCap",
+  "lifetime-min-spend": "lifetimeMinSpendTarget",
+  "lifetime-spend-cap": "lifetimeSpendCap",
+  schedule: "adset_schedule",
+  boosts: "budgetSchedules",
+  "budget-boost": "budgetSchedules"
+};
+var NOT_CLEARABLE = {
+  "min-roas": "a ROAS floor goes with ROAS goal bidding \u2014 switch --bid-strategy (e.g. LOWEST_COST_WITHOUT_CAP) and Baker drops the floor",
+  "frequency-cap": "Meta keeps a frequency cap on a reach ad set whatever is sent (an empty cap is accepted and ignored) \u2014 set another with --frequency-cap"
+};
+function clearFromFlags(rawArgs, entity) {
+  const names = repeatedValues(rawArgs, "clear", void 0).flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).filter(Boolean);
+  if (names.length === 0) return void 0;
+  const fields = names.map((name) => {
+    const why = NOT_CLEARABLE[name];
+    if (why) throw new Error(`--clear ${name}: ${why}`);
+    const field = CLEAR_FLAGS[name];
+    if (!field || entity === "campaign" && field !== "budgetSchedules") {
+      const takes = entity === "campaign" ? "boosts" : Object.keys(CLEAR_FLAGS).join(", ");
+      throw new Error(`--clear takes ${takes} \u2014 not "${name}"`);
+    }
+    return field;
+  });
+  return [...new Set(fields)];
+}
+var clearArg = {
+  clear: {
+    type: "string",
+    description: "Take a delivery control away (repeatable or comma-separated): daily-min-spend, daily-spend-cap, lifetime-min-spend, lifetime-spend-cap, schedule (back to standard pacing), boosts (every budget boost it has now). A ROAS floor goes by switching --bid-strategy; Meta keeps a reach ad set's frequency cap."
+  }
+};
+
+export {
+  dayPartingFromFlags,
+  adSetDeliveryFromFlags,
+  budgetBoostsFromFlags,
+  boostEditsFromFlags,
+  boostEditArgs,
+  adSetDeliveryArgs,
+  budgetBoostArg,
+  clearFromFlags,
+  clearArg
+};
+//# sourceMappingURL=chunk-XNUUEUJB.js.map

package/dist/chunk-YB2UVOAD.js

@@ -0,0 +1,64 @@
+import {
+  ApiError
+} from "./chunk-JCFZ7ECN.js";
+import {
+  writeJson
+} from "./chunk-NXNOXZGB.js";
+
+// src/commands/media-sources/shared.ts
+function driveRefusalFix(input, code) {
+  if (!/drive\.google\.com/i.test(input) || code !== "BAD_REQUEST") return void 0;
+  return `A Google Drive folder is never added by link \u2014 don't retry. Call request_connection with platform "google-drive" and choose "media-folder": the card lets the user pick the folder in the chat (only the Baker team can for now; anyone else is told the team will set it up). A connected result carries the new source's mediaSourceKey; if it is declined, carry on with the rest of the task.`;
+}
+function reportError(err, input) {
+  if (err instanceof ApiError) {
+    const fix = input ? driveRefusalFix(input, err.code) : void 0;
+    writeJson({ ok: false, error: { code: err.code, message: err.message, ...fix ? { fix } : {} } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function halfState(half) {
+  if (!half) return null;
+  return {
+    status: half.syncStatus === "fetching" || half.syncStatus === "processing" ? "importing" : half.syncStatus,
+    stored: half.storedCount ?? 0,
+    ...half.pendingItems ? { pending: half.pendingItems } : {},
+    ...half.failedItems ? { failed: half.failedItems } : {},
+    ...half.lastSyncedAt ? { lastSyncedAt: new Date(half.lastSyncedAt).toISOString() } : {},
+    ...half.errorMessage ? { error: half.errorMessage } : {}
+  };
+}
+function whoLine(who) {
+  return [
+    who.kind === "person" ? "person" : "page",
+    who.role,
+    who.own ? "own" : "not own",
+    who.privateProfile ? "private profile \u2014 add posts by link" : void 0
+  ].filter(Boolean).join(" \xB7 ");
+}
+function compactSource(source) {
+  return {
+    key: source.key,
+    platform: source.platform,
+    label: source.label,
+    url: source.profileUrl,
+    ...source.who ? { who: whoLine(source.who) } : {},
+    autoSync: source.refreshInterval,
+    images: halfState(source.images),
+    videos: halfState(source.videos)
+  };
+}
+function isImporting(source) {
+  return [source.images, source.videos].some(
+    (half) => half?.syncStatus === "fetching" || half?.syncStatus === "processing"
+  );
+}
+
+export {
+  reportError,
+  compactSource,
+  isImporting
+};
+//# sourceMappingURL=chunk-YB2UVOAD.js.map

package/dist/chunk-YP5SD6O2.js

@@ -0,0 +1,148 @@
+import {
+  RULES_DIR,
+  SAME_WORDS,
+  frontmatterOf,
+  parseIdea,
+  parseInsight
+} from "./chunk-BNEWJXKU.js";
+import {
+  rememberedJev
+} from "./chunk-HZ7QUFUW.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-T4HIFVNK.js";
+
+// src/commands/creatives/ideas-judgments.ts
+var STATISTIC_QUESTION = `\`quote\` was filed as something a customer said. Is it instead a statistic about a group of people, a share or a figure from a survey, a study or an article ("39% of UK homeowners say\u2026", "a quarter of buyers\u2026", "1 in 3 owners\u2026"), rather than one person's own words about their own experience? A person giving their own number ("My bill dropped 40%") is their own words. The quote may be in any language.`;
+var STATISTIC_HELD = 0.65;
+var SAME_MESSAGE_QUESTION = `\`a\` and \`b\` are the messages of two ads. Do they make the same core promise to the viewer (the same benefit, the same reason to act), even when one adds a detail or a few words, says it in other words, or is in another language? Two messages that promise different things about the same product are not the same.`;
+var SAME_MESSAGE_HELD = 0.42;
+async function withStatisticsRead(insights, ask) {
+  const observed = insights.filter((i) => i.status === "observed");
+  if (observed.length === 0) return [...insights];
+  const answers = await ask(observed.map((i) => ({ instructions: { quote: i.quote, question: STATISTIC_QUESTION } })));
+  if (answers === null) return [...insights];
+  const statistics = new Set(observed.filter((_, i) => (answers[i] ?? 0) >= STATISTIC_HELD).map((i) => i.id));
+  return insights.map((i) => statistics.has(i.id) ? { ...i, status: "interpreted" } : i);
+}
+async function sameMessageRead(ideas, ask) {
+  const failed = ideas.filter((i) => i.status === "failed");
+  const pairs = failed.flatMap(
+    (f) => ideas.filter((i) => i.id !== f.id && !SAME_WORDS(i.message, f.message)).map((i) => [f.message, i.message])
+  );
+  if (pairs.length === 0) return SAME_WORDS;
+  const answers = await ask(pairs.map(([a, b]) => ({ instructions: { a, b, question: SAME_MESSAGE_QUESTION } })));
+  if (answers === null) return SAME_WORDS;
+  const same = new Set(
+    pairs.filter((_, i) => (answers[i] ?? 0) >= SAME_MESSAGE_HELD).map(([a, b]) => `${a}\0${b}`)
+  );
+  return (a, b) => SAME_WORDS(a, b) || same.has(`${a}\0${b}`) || same.has(`${b}\0${a}`);
+}
+
+// src/commands/creatives/ideas-workspace.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+var IDEAS_DIR = path.join("src", "creatives", "_ideas");
+var INSIGHTS_DIR = path.join("src", "content", "insights");
+async function markdownFiles(dir, recursive = false) {
+  const entries = await readdir(dir, { recursive }).catch(() => []);
+  return entries.filter((f) => f.endsWith(".md")).sort();
+}
+var idOf = (file) => file.replace(/\\/g, "/").replace(/\.md$/, "");
+function workspaceIdeasJudge(root) {
+  const cacheDir = path.join(root, "canvas", ".cache");
+  const spent = [];
+  return {
+    ask: rememberedJev(path.join(cacheDir, "ideas-answers.json"), (u) => spent.push(u)),
+    done: () => holdUnbilledSpend(cacheDir, spent.splice(0)).catch(() => void 0)
+  };
+}
+async function readInsights(root, opts = {}) {
+  const dir = path.join(root, INSIGHTS_DIR);
+  const insights = [];
+  for (const file of await markdownFiles(dir, true)) {
+    const insight = parseInsight(idOf(file), await readFile(path.join(dir, file), "utf8").catch(() => ""));
+    if (insight) insights.push(insight);
+  }
+  if (opts.ask) return withStatisticsRead(insights, opts.ask);
+  const judge = workspaceIdeasJudge(root);
+  const read = await withStatisticsRead(insights, judge.ask);
+  await judge.done();
+  return read;
+}
+async function readIdeas(root) {
+  const dir = path.join(root, IDEAS_DIR);
+  const ideas = [];
+  const unreadable = [];
+  for (const file of await markdownFiles(dir)) {
+    const id = idOf(file);
+    const parsed = parseIdea(id, await readFile(path.join(dir, file), "utf8").catch(() => ""));
+    if (parsed.idea) ideas.push(parsed.idea);
+    else unreadable.push({ id, problems: parsed.problems });
+  }
+  return { ideas, unreadable };
+}
+async function readPersonaIds(root) {
+  return (await markdownFiles(path.join(root, "src", "content", "personas"), true)).map(idOf);
+}
+var MAX_KNOWLEDGE_CHARS = 2e5;
+async function readKnowledgeCorpus(root) {
+  const parts = [];
+  const company = await readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => "");
+  if (company) parts.push(company);
+  const content = path.join(root, "src", "content");
+  const insights = path.relative(content, path.join(root, INSIGHTS_DIR));
+  const rules = path.relative(content, path.join(root, RULES_DIR));
+  const files = (await markdownFiles(content, true)).filter((f) => {
+    const file = f.replace(/\\/g, "/");
+    return !file.startsWith(`${insights}/`) && !file.startsWith(`${rules}/`);
+  });
+  for (const file of files) {
+    parts.push(await readFile(path.join(content, file), "utf8").catch(() => ""));
+    if (parts.join("").length > MAX_KNOWLEDGE_CHARS) break;
+  }
+  return parts.join("\n").slice(0, MAX_KNOWLEDGE_CHARS);
+}
+async function readCreativeRecords(root) {
+  const dir = path.join(root, "src", "creatives");
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
+    const raw = await readFile(path.join(dir, entry.name, "_definition.md"), "utf8").catch(() => null);
+    if (raw === null) continue;
+    const fm = frontmatterOf(raw) ?? {};
+    const pick = (key) => typeof fm[key] === "string" && fm[key] ? { [key]: fm[key] } : {};
+    records.push({
+      slug: entry.name,
+      ...pick("status"),
+      ...pick("idea"),
+      ...pick("awareness"),
+      ...pick("angle"),
+      ...pick("kind")
+    });
+  }
+  return records;
+}
+var SHOWN_STATUSES = /* @__PURE__ */ new Set(["rendered", "published"]);
+function coverageOf(ideas, creatives) {
+  const live = ideas.filter((i) => i.status === "built" || i.status === "testing" || i.status === "winner");
+  const awareness = new Set(live.map((i) => i.awareness));
+  for (const creative of creatives) {
+    if (creative.awareness && SHOWN_STATUSES.has(creative.status ?? "")) awareness.add(creative.awareness);
+  }
+  return { coveredAwareness: [...awareness].sort(), closersLive: live.filter((i) => i.job === "closer").length };
+}
+
+export {
+  sameMessageRead,
+  IDEAS_DIR,
+  workspaceIdeasJudge,
+  readInsights,
+  readIdeas,
+  readPersonaIds,
+  readKnowledgeCorpus,
+  readCreativeRecords,
+  coverageOf
+};
+//# sourceMappingURL=chunk-YP5SD6O2.js.map