@koda-sl/baker-cli 0.551.0 → 0.553.0

package/dist/chunk-XSBX3LJP.js

@@ -0,0 +1,430 @@
+import {
+  agentProfile
+} from "./chunk-WR5Y64OE.js";
+import {
+  AUTO_PUBLISH_REFUSAL,
+  MAX_AI_CONDITION_CHARS,
+  TRIGGER_KINDS,
+  TRIGGER_KIND_IDS,
+  TRIGGER_TARGETS,
+  TRIGGER_TARGET_FIELDS,
+  TRIGGER_TARGET_FIELD_IDS,
+  firstTimes,
+  isTriggerKind,
+  parseConditionsExpression
+} from "./chunk-RCNAKWK7.js";
+import {
+  ApiError,
+  validateConvexId
+} from "./chunk-GFWWHCBF.js";
+import {
+  getEnv
+} from "./chunk-45D6WRCJ.js";
+import {
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+
+// src/commands/scheduled-agents/shared.ts
+var TEMP_SCHEDULED_AGENT_PREFIX = "temp_agent_";
+var TEMP_ID_PREFIX = "temp_";
+function writeOk(data, hints) {
+  writeJson({ ok: true, data: data ?? null, ...hints && hints.length > 0 ? { hints } : {} });
+}
+function failValidation(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function failApi(err) {
+  if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+var AUTO_PUBLISH_ARG = {
+  "auto-publish": {
+    type: "string",
+    description: "Not available to the agent: publishing every run unreviewed is switched on by the user, on the item, after this chat is published. Passing it is refused and tells you what to ask them.",
+    required: false
+  }
+};
+function refuseAutoPublish(args) {
+  if (args["auto-publish"] === void 0) {
+    return;
+  }
+  writeJson({
+    ok: false,
+    error: {
+      code: "FORBIDDEN",
+      message: AUTO_PUBLISH_REFUSAL,
+      fix: {
+        action: "ask_user",
+        explanation: 'Run the command again without --auto-publish. After this chat is published, ask the user to open the item in Scheduled agents and switch on "Publish its work on its own" under "When a run finishes" \u2014 until then each run waits for their review.'
+      }
+    }
+  });
+  process.exit(1);
+}
+function isTempScheduledAgentId(id) {
+  return id.startsWith(TEMP_SCHEDULED_AGENT_PREFIX);
+}
+function isOtherTempId(id) {
+  return id.startsWith(TEMP_ID_PREFIX) && !isTempScheduledAgentId(id);
+}
+function validateScheduledAgentRef(ref) {
+  if (isOtherTempId(ref)) {
+    failValidation(`Scheduled agent temp IDs must start with ${TEMP_SCHEDULED_AGENT_PREFIX}.`);
+  }
+  if (!isTempScheduledAgentId(ref)) {
+    validateConvexId(ref);
+  }
+}
+var TRIGGER_ARG_DESCRIPTION = `What makes this run. ${TRIGGER_KIND_IDS.map(
+  (id) => `${id}: ${TRIGGER_KINDS[id].description}`
+).join(" ")} For the two time ones, pass --cron or --run-at instead and the kind is implied.`;
+var TRIGGER_KIND_LIST = [...TRIGGER_KIND_IDS];
+var NARROWING_DESCRIPTIONS = {
+  eventName: "With --trigger event.received: only this event name (a source's name, or one your site sends). Omit it to run on any event.",
+  toolkit: "With --trigger app.event (required): the connected tool, by its slug \u2014 gmail, slack, googlesheets.",
+  account: "With --trigger app.event (required): which connected account of that tool, by id (a tool can be connected more than once).",
+  appEvent: "With --trigger app.event (required): what happens in the tool, by the tool's own id \u2014 GMAIL_NEW_GMAIL_MESSAGE. `targets --field appEvent --app <tool>` lists them with the settings each needs.",
+  provider: "With --trigger connection.created, connection.removed or connection.needs_reconnect: only this tool (google-ads, hubspot, meta, or a connected tool's slug such as slack). Omit it for any tool.",
+  flowId: "With --trigger form.submitted or flow.step.submitted: which Form, by slug. Omit it on form.submitted for any Form.",
+  stepId: "With --trigger flow.step.submitted: which step of that Form, by id \u2014 `targets --field stepId --form <slug>` lists them by name.",
+  page: "With --trigger landing.created or landing.published: only this page, by slug. Omit it for any page.",
+  tag: "With --trigger task.created, task.claimed, task.completed, landing.created or landing.published: only ones carrying this tag. Omit it for any.",
+  experimentId: 'With --trigger experiment.decided, experiment.ended or experiment.concluded: only this test. Omit it for any test. Not for experiment.started \u2014 narrow that with --when "page = <page>".',
+  taskId: "With --trigger task.claimed or task.completed: only this Task, by id (a temp_ id of a Task staged in this chat works too). Omit it for any Task.",
+  agentId: "With --trigger session.published, session.publish_failed or session.publish_incomplete: only the runs of this scheduled agent, by id (a temp_agent_ id staged in this chat works too). Required on session.published from a chat \u2014 to follow up on this chat's own publish, use --trigger session.settled --session this.",
+  platform: "With --trigger session.publish_incomplete: only when this platform's changes did not all land \u2014 google-ads, meta-ads, linkedin-ads, x-ads, chatgpt-ads, tag-manager, ga4 or shopify. Omit it for any.",
+  collection: "With --trigger knowledge.updated: only this Knowledge collection. Omit it for any of them.",
+  sourceId: "With --trigger review.received: only reviews from this review source, by id. Omit it for any source.",
+  advertiserId: "With --trigger advertiser.new_ads: only this followed advertiser, by id. Omit it for any of them.",
+  adAccount: "With --trigger ad_alert.opened, ad_alert.claimed, ad_alert.fixed or ad_alert.closed: only alerts on this ad account, as <platform>:<ad account id> (meta:123). Omit it for any account.",
+  alertRule: 'With --trigger ad_alert.opened, ad_alert.claimed, ad_alert.fixed or ad_alert.closed: only this kind of alert, by the rule `baker ads performance attention` names (budget_cut, efficiency_degraded, tracking_broke). Omit it for any. Narrow by severity with --when "severity = critical".',
+  socialAccount: "With --trigger social.post_published: only posts by this followed account, by its key (linkedin:in/jacintofleta, instagram:nike \u2014 `baker media-sources list`). Omit it for any account.",
+  chatId: "With --trigger session.settled (required): `this` \u2014 the chat you are in. It runs once, after this chat is published and its work is fully live: pages served, every ad, Tag Manager, Analytics and store change landed or failed. Start here for any check or report on this chat's own work after it publishes.",
+  personRole: "With --trigger social.post_published: only posts by people with this role \u2014 ceo, founder, cto, cmo, head_of_sales, sales, marketing, employee, creator. Omit it for any account, pages included."
+};
+var NARROWING_ARGS = {
+  ...Object.fromEntries(
+    TRIGGER_TARGET_FIELD_IDS.map((field) => [
+      TRIGGER_TARGET_FIELDS[field].flag,
+      {
+        type: "string",
+        description: `${NARROWING_DESCRIPTIONS[field]} \`baker scheduled-agents targets --trigger <kind> --field ${field}\` lists the values.`,
+        required: false
+      }
+    ])
+  ),
+  config: {
+    type: "string",
+    description: `With --trigger app.event: the event's own settings as a JSON object \u2014 they filter inside the tool, before anything is sent. A Gmail search ('{"query":"from:ana@acme.com"}'), a label, a Slack channel, a GitHub repository ('{"owner":"acme","repo":"site"}'). \`targets --field appEvent --app <tool> --event <id>\` lists each setting with its examples.`,
+    required: false
+  }
+};
+function validateRunAt(runAt) {
+  if (!runAt.endsWith("Z")) {
+    failValidation("--run-at must be an ISO UTC timestamp ending in Z.");
+  }
+  const parsed = Date.parse(runAt);
+  if (!Number.isFinite(parsed)) {
+    failValidation("--run-at must be a valid ISO timestamp.");
+  }
+  if (parsed <= Date.now()) {
+    failValidation(
+      `--run-at ${runAt} has already passed. A one-off item only runs at a time still to come \u2014 pass a later ISO UTC timestamp, and check which timezone you converted from if you worked it out from a local time.`
+    );
+  }
+}
+function buildTriggerBody(args, options) {
+  const cron = args.cron;
+  const runAt = args["run-at"];
+  const timezone = args.timezone;
+  const kind = args.trigger;
+  const given = [cron, runAt, kind].filter(Boolean).length;
+  if (given > 1) {
+    failValidation("--cron, --run-at and --trigger are mutually exclusive.");
+  }
+  refuseNarrowingWithoutKind(args, kind, given);
+  if (runAt) {
+    validateRunAt(runAt);
+    return { runAt, ...timezone ? { timezone } : {} };
+  }
+  if (cron) {
+    return { cron, ...timezone ? { timezone } : {} };
+  }
+  if (kind) {
+    return { trigger: triggerFromFlags(kind, args), ...timezone ? { timezone } : {} };
+  }
+  if (timezone && !options.required) {
+    return { timezone };
+  }
+  if (options.required) {
+    failValidation(
+      `A trigger is required. Pass --cron or --run-at for a time-based one, or --trigger with one of: ${TRIGGER_KIND_IDS.join(", ")}.`
+    );
+  }
+  return void 0;
+}
+function flagText(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function refuseMisusedKinds(kind, args) {
+  if (kind === "time.once") {
+    failValidation("Use --run-at for a one-off, rather than --trigger time.once.");
+  }
+  if (kind === "time.cron") {
+    failValidation("Use --cron for a repeating schedule, rather than --trigger time.cron.");
+  }
+  if (kind === "experiment.started" && flagText(args, "experiment")) {
+    failValidation(
+      'A test that exists has already started, so --experiment never fires on experiment.started. Leave it off and add --when "page = <page>" to watch one page.'
+    );
+  }
+}
+function refuseStrayFlags(kind, args) {
+  const allowed = new Set(TRIGGER_TARGETS[kind].map((target) => TRIGGER_TARGET_FIELDS[target.field].flag));
+  const stray = TRIGGER_TARGET_FIELD_IDS.map((field) => TRIGGER_TARGET_FIELDS[field].flag).filter(
+    (flag) => !allowed.has(flag) && flagText(args, flag) !== void 0 && !(kind === "experiment.started" && flag === "experiment")
+  );
+  if (stray.length === 0) {
+    return;
+  }
+  failValidation(
+    `${stray.map((flag) => `--${flag}`).join(", ")} does not narrow ${kind}. ${allowed.size > 0 ? `It can be pointed with ${[...allowed].map((flag) => `--${flag}`).join(", ")}.` : "It runs every time it happens \u2014 narrow it with --when rules over its payload instead."}`
+  );
+}
+var NARROWING_FLAGS = [...TRIGGER_TARGET_FIELD_IDS.map((field) => TRIGGER_TARGET_FIELDS[field].flag), "config"];
+function refuseNarrowingWithoutKind(args, kind, given) {
+  if (kind) {
+    return;
+  }
+  const stray = NARROWING_FLAGS.filter((flag) => flagText(args, flag) !== void 0);
+  if (stray.length === 0) {
+    return;
+  }
+  const flags = stray.map((flag) => `--${flag}`).join(", ");
+  failValidation(
+    given > 0 ? `${flags} does not narrow --cron or --run-at: a time trigger runs every time it comes round. Use --trigger <kind> with ${flags} instead, or leave ${flags} off.` : `${flags} narrows a trigger, and no trigger was given. Pass --trigger <kind> too \u2014 the item's whole trigger, with ${flags} \u2014 or leave ${flags} off.`
+  );
+}
+function configFromFlag(kind, args) {
+  const config = flagText(args, "config");
+  if (!config) {
+    return {};
+  }
+  if (kind !== "app.event") {
+    failValidation("--config is only for --trigger app.event: the settings of what happens in the tool.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(config);
+  } catch {
+    parsed = null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    failValidation(`--config must be a JSON object, e.g. '{"labelIds":"INBOX"}'.`);
+  }
+  return { configJson: config };
+}
+function withoutMetaActPrefix(adAccount) {
+  return adAccount.replace(/^meta:act_/i, "meta:");
+}
+function triggerFromFlags(kind, args) {
+  if (!isTriggerKind(kind)) {
+    failValidation(`--trigger must be one of: ${TRIGGER_KIND_IDS.join(", ")}.`);
+  }
+  refuseMisusedKinds(kind, args);
+  refuseStrayFlags(kind, args);
+  const narrowings = {};
+  for (const { field, required } of TRIGGER_TARGETS[kind]) {
+    const value = flagText(args, TRIGGER_TARGET_FIELDS[field].flag);
+    if (value) {
+      narrowings[field] = field === "adAccount" ? withoutMetaActPrefix(value) : value;
+    } else if (required) {
+      failValidation(
+        `--trigger ${kind} needs --${TRIGGER_TARGET_FIELDS[field].flag}. \`baker scheduled-agents targets --trigger ${kind} --field ${field}\` lists what it can be.`
+      );
+    }
+  }
+  return { kind, ...narrowings, ...configFromFlag(kind, args) };
+}
+function parseOccurrences(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    failValidation("--occurrences must be a comma-separated list of whole numbers, e.g. 1 or 1,3.");
+  }
+  const parts = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  const numbers = parts.map((part) => Number(part));
+  if (numbers.length === 0 || numbers.some((n) => !Number.isInteger(n) || n <= 0)) {
+    failValidation("--occurrences must be a comma-separated list of whole numbers above zero, e.g. 1 or 1,3.");
+  }
+  return numbers;
+}
+function parseBooleanFlag(raw, flagName) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw === true || raw === "true") {
+    return true;
+  }
+  if (raw === false || raw === "false") {
+    return false;
+  }
+  failValidation(`${flagName} must be true or false.`);
+}
+var REACTION_ARGS = {
+  when: {
+    type: "string",
+    description: "Only run when what arrived passes these rules: `<field> <operator> <value>` joined by AND or by OR (either case). Fields are the trigger's payload fields (`baker scheduled-agents triggers --trigger <kind>` lists them; a webhook's are whatever was posted; an app.event's are what `targets --field appEvent --app <tool> --event <id>` says it sends). Operators: =, !=, contains, does not contain, starts with, ends with, >, <, >=, <=, in (comma list), exists, missing. Example: --when \"deal.stage = won AND amount > 10000\". A payload that fails is not counted and starts nothing. `none` clears the rules.",
+    required: false
+  },
+  "ai-check": {
+    type: "string",
+    description: 'Only run when AI judges that what arrived meets this condition, in plain words \u2014 for what no --when rule can say: --ai-check "the person writes on behalf of a company, not as a student or for personal use". Checked after --when, on what passed it; a turned-down arrival is not counted and starts nothing, and shows in `history` with its score. Say the boundary cases ("a freelancer counts as a company"). Emails and phones are hidden from it, as from the run \u2014 an email domain is a --when rule. Not for a time-based start (--cron, --run-at). `none` removes it.',
+    required: false
+  },
+  times: {
+    type: "string",
+    description: "Only the first N times it fires (and its --when rules pass), then never again. `--times 1` is only the first time. Shorthand for --occurrences 1,2,\u2026,N.",
+    required: false
+  },
+  payload: {
+    type: "string",
+    description: "include (default) or omit. Whether the run's first message carries what arrived \u2014 the posted body, the event's properties, the Form's answers (emails and phones masked). Place single values in --prompt with {{payload.<field>}} instead; those are filled either way.",
+    required: false
+  },
+  cooldown: {
+    type: "string",
+    description: "At most one run per this many minutes, however often it fires. 0 removes it.",
+    required: false
+  }
+};
+var SLACK_ARG = {
+  slack: {
+    type: "string",
+    description: "Tell each run in Slack: `here` (the Slack conversation this chat came from), `me` (a direct message to the person in this chat), `#channel` (a channel linked to this company), or `off`. Each run opens its own thread there and Baker reports on it: what it found, what it needs, whether to publish.",
+    required: false
+  }
+};
+function companiesArg(profile = agentProfile()) {
+  return profile === "organization" ? {
+    companies: {
+      type: "string",
+      description: "The companies whose events it hears, by id, comma-separated (`baker organization companies` lists them), or `all`. Left out, it hears every company, including ones added later. Only on a trigger that happens in a company; one company's Form, page or tag is a --when rule instead.",
+      required: false
+    }
+  } : {};
+}
+function companiesBody(args) {
+  return typeof args.companies === "string" && args.companies.trim().length > 0 ? { companies: args.companies.trim() } : {};
+}
+function slackBody(args) {
+  return typeof args.slack === "string" && args.slack.trim().length > 0 ? { slack: args.slack.trim() } : {};
+}
+function wholeNumber(raw, flag, { min }) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < min) {
+    failValidation(`${flag} must be a whole number of at least ${min}.`);
+  }
+  return value;
+}
+function reactionBody(args) {
+  const occurrences = occurrencesFromFlags(args);
+  const when = whenFromFlag(args.when);
+  const includePayload = payloadFromFlag(args.payload);
+  const cooldownMinutes = wholeNumber(args.cooldown, "--cooldown", { min: 0 });
+  const aiCondition = aiCheckFromFlag(args["ai-check"]);
+  return {
+    ...occurrences !== void 0 ? { occurrences } : {},
+    ...when !== void 0 ? { when } : {},
+    ...aiCondition !== void 0 ? { aiCondition } : {},
+    ...includePayload !== void 0 ? { includePayload } : {},
+    ...cooldownMinutes !== void 0 ? { cooldownMinutes } : {}
+  };
+}
+function occurrencesFromFlags(args) {
+  const times = wholeNumber(args.times, "--times", { min: 1 });
+  const occurrences = parseOccurrences(args.occurrences);
+  if (times !== void 0 && occurrences !== void 0) {
+    failValidation("Pass --times or --occurrences, not both \u2014 --times 3 is --occurrences 1,2,3.");
+  }
+  return times !== void 0 ? firstTimes(times) : occurrences;
+}
+function whenFromFlag(raw) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const text = raw.trim();
+  if (text.length === 0 || text.toLowerCase() === "none") {
+    return "none";
+  }
+  const parsed = parseConditionsExpression(text);
+  if (!parsed.ok) {
+    failValidation(parsed.error);
+  }
+  return text;
+}
+function aiCheckFromFlag(raw) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const text = raw.trim();
+  if (text.length === 0 || text.toLowerCase() === "none") {
+    return "none";
+  }
+  if (text.length > MAX_AI_CONDITION_CHARS) {
+    failValidation(
+      `--ai-check is at most ${MAX_AI_CONDITION_CHARS} characters: say the condition, not the job. The job goes in --prompt.`
+    );
+  }
+  return text;
+}
+function payloadFromFlag(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw !== "include" && raw !== "omit") {
+    failValidation("--payload must be include or omit.");
+  }
+  return raw === "include";
+}
+function chatBody() {
+  const id = getEnv().BAKER_CHAT_ID;
+  return id ? { chatId: id } : {};
+}
+
+export {
+  writeOk,
+  failValidation,
+  failApi,
+  AUTO_PUBLISH_ARG,
+  refuseAutoPublish,
+  isTempScheduledAgentId,
+  validateScheduledAgentRef,
+  TRIGGER_ARG_DESCRIPTION,
+  TRIGGER_KIND_LIST,
+  NARROWING_ARGS,
+  buildTriggerBody,
+  parseBooleanFlag,
+  REACTION_ARGS,
+  SLACK_ARG,
+  companiesArg,
+  companiesBody,
+  slackBody,
+  reactionBody,
+  chatBody
+};
+//# sourceMappingURL=chunk-XSBX3LJP.js.map

package/dist/chunk-XXBP73RV.js

@@ -0,0 +1,148 @@
+import {
+  RULES_DIR,
+  SAME_WORDS,
+  frontmatterOf,
+  parseIdea,
+  parseInsight
+} from "./chunk-UKZKLXTE.js";
+import {
+  rememberedJev
+} from "./chunk-4H6XLX7E.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-Y3SK6EMU.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-XXBP73RV.js.map

package/dist/chunk-XZMO52BP.js

@@ -0,0 +1,56 @@
+import {
+  ApiError,
+  apiGet
+} from "./chunk-GFWWHCBF.js";
+import {
+  compactImage,
+  compactVideo,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+
+// src/commands/mediaGroup.ts
+async function runMediaGroupLookup(input) {
+  if (!input.id && !input.groupKey) {
+    writeJson({
+      ok: false,
+      error: { code: "VALIDATION_ERROR", message: `Pass ${input.idLabel} or --group-key` }
+    });
+    process.exit(1);
+  }
+  try {
+    const query = new URLSearchParams();
+    if (input.id) query.set("id", input.id);
+    if (input.groupKey) query.set("groupKey", input.groupKey);
+    const data = await apiGet(`${input.path}?${query.toString()}`);
+    const images = data.images.map((image) => compactImage(image));
+    const videos = (data.videos ?? []).map((video) => compactVideo(video));
+    const count = images.length + videos.length;
+    writeJson({
+      ok: true,
+      data: {
+        groupKey: data.groupKey,
+        groupKind: data.groupKind ?? null,
+        // The caption or page title the whole set shares — often the only
+        // place the campaign is named.
+        groupTitle: data.groupTitle ?? null,
+        groupUrl: data.groupUrl ?? null,
+        count,
+        images,
+        videos
+      },
+      hints: count > 1 ? ["These arrived together and are ordered. Read them in sequence before using any one of them alone."] : void 0
+    });
+  } catch (err) {
+    if (err instanceof ApiError) {
+      writeJson({ ok: false, error: { code: err.code, message: err.message } });
+      process.exit(1);
+    }
+    writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+    process.exit(1);
+  }
+}
+
+export {
+  runMediaGroupLookup
+};
+//# sourceMappingURL=chunk-XZMO52BP.js.map