@koda-sl/baker-cli 0.501.0-dev.6e96f50b9 → 0.502.0

package/dist/chunk-3LFPQSSC.js

@@ -0,0 +1,406 @@
+import {
+  agentProfile
+} from "./chunk-ASRS37QE.js";
+import {
+  AUTO_PUBLISH_REFUSAL,
+  TRIGGER_KINDS,
+  TRIGGER_KIND_IDS,
+  TRIGGER_TARGETS,
+  TRIGGER_TARGET_FIELDS,
+  TRIGGER_TARGET_FIELD_IDS,
+  firstTimes,
+  isTriggerKind,
+  parseConditionsExpression
+} from "./chunk-5MSRVAUZ.js";
+import {
+  ApiError,
+  validateConvexId
+} from "./chunk-X7VQFLHI.js";
+import {
+  getEnv
+} from "./chunk-LGK7UWBN.js";
+import {
+  writeJson
+} from "./chunk-Q7US4OOA.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). Omit it for any agent's work.",
+  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.",
+  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
+  },
+  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 });
+  return {
+    ...occurrences !== void 0 ? { occurrences } : {},
+    ...when !== void 0 ? { when } : {},
+    ...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 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-3LFPQSSC.js.map

package/dist/chunk-3YJNSUNF.js

@@ -0,0 +1,131 @@
+import {
+  holdUnbilledSpend
+} from "./chunk-E44NXCTL.js";
+import {
+  askAboutText
+} from "./chunk-7HZSORAB.js";
+
+// src/engine/brand/brand-doc.ts
+import { createHash } from "crypto";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var BRAND_DOC_MODEL = "google/gemini-3.5-flash-lite";
+var REQUEST = {
+  provider: { order: ["google-vertex"], allow_fallbacks: false },
+  seed: 0,
+  response_format: { type: "json_object" }
+};
+var PROMPT_VERSION = 3;
+var TIMEOUT_MS = 3e4;
+var BRAND_MD_CHARS = 32e3;
+var NOTE_CHARS = 600;
+var COMPANY_MD_CHARS = 4e3;
+var Font = z.object({
+  family: z.string().trim().min(1).max(60),
+  role: z.enum(["heading", "body", "any"]).catch("any"),
+  use: z.boolean()
+});
+var Color = z.object({
+  hex: z.string().trim().regex(/^#?[0-9a-fA-F]{6}$/).transform((h) => `#${h.replace(/^#/, "").toLowerCase()}`),
+  use: z.boolean()
+});
+var note = z.string().trim().min(1).max(NOTE_CHARS).nullable().optional().catch(null);
+var Reading = z.object({
+  name: z.string().trim().min(1).max(80).nullable().catch(null),
+  wordmark: z.array(z.string().trim().min(1).max(40)).catch([]),
+  logoNames: z.array(z.string().trim().min(1).max(40)).catch([]),
+  fonts: z.array(z.unknown()).catch([]),
+  colors: z.array(z.unknown()).catch([]),
+  voice: note,
+  imagery: note,
+  logoUsage: note
+});
+function brandDocPrompt(docs) {
+  return [
+    "You read a company's brand guidelines (BRAND.md), the start of its company profile (COMPANY.md) and the file names of its logos. They may be written in any language, or several. Extract only what they state; never invent a value.",
+    "",
+    "Return JSON only, in this shape:",
+    '{"name": string | null, "wordmark": string[], "logoNames": string[], "fonts": [{"family": string, "role": "heading" | "body" | "any", "use": boolean}], "colors": [{"hex": "#rrggbb", "use": boolean}], "voice": string | null, "imagery": string | null, "logoUsage": string | null}',
+    "",
+    `- name: the brand's name exactly as written ("# Zernio Brand Guidelines" names Zernio). null when neither document states one, as in an unfilled template ("# Brand Guidelines", "# Company", TODO).`,
+    `- wordmark: every word the documents say the logo prints, as they quote it ("Wordmark: \\"permut\\"" gives "permut"; 'symbol plus "Cubbo" wordmark' gives "Cubbo"), even when it is also the name. [] when they quote none.`,
+    '- logoNames: a product or brand name a logo file name carries ("logo-engage-blue.png" gives "Engage"). Colours, variants, sizes and formats (dark, white, icon, isotype, png) are not names. [] when none.',
+    `- fonts: every typeface the guidelines name, by its family name exactly, the banned ones included. role is heading, body, or any when they do not say. use is false when the guidelines ban it, forbid it or say to avoid it or never use it, in any wording or language; true when the brand uses it. Only a named typeface counts: a generic family (sans-serif, serif, monospace, system-ui) or the operating system's own fonts ("system stack", "system fonts") is not one, so leave it out.`,
+    "- colors: every hex colour the guidelines give. use is false when they ban it or say to avoid it, true when it is a brand colour.",
+    "- voice: how the brand speaks, as the guidelines put it, at most two sentences in their language. null when they do not say.",
+    "- imagery: what the brand's pictures look like and never look like (photography, illustration, people; a ```generation-style block says it too), at most two sentences in their language. null when they do not say.",
+    "- logoUsage: which logo file an ad uses and how it must appear (which file for which product, line or background, what never to do to it), at most two sentences in their language. null when they do not say.",
+    "",
+    "<brand_md>",
+    (docs.brandMd ?? "").slice(0, BRAND_MD_CHARS),
+    "</brand_md>",
+    "<company_md>",
+    (docs.companyMd ?? "").slice(0, COMPANY_MD_CHARS),
+    "</company_md>",
+    "<logo_files>",
+    (docs.logoFiles ?? []).join("\n"),
+    "</logo_files>"
+  ].join("\n");
+}
+function parseBrandDoc(answer) {
+  const parsed = Reading.safeParse(answer);
+  if (!parsed.success) return null;
+  const fonts = parsed.data.fonts.flatMap((f) => {
+    const font = Font.safeParse(f);
+    return font.success ? [font.data] : [];
+  });
+  const colors = parsed.data.colors.flatMap((c) => {
+    const color = Color.safeParse(c);
+    return color.success ? [color.data] : [];
+  });
+  const { voice, imagery, logoUsage } = parsed.data;
+  return {
+    ...parsed.data.name ? { name: parsed.data.name } : {},
+    wordmark: [.../* @__PURE__ */ new Set([...parsed.data.wordmark, ...parsed.data.logoNames])],
+    fonts,
+    colors,
+    ...voice ? { voice } : {},
+    ...imagery ? { imagery } : {},
+    ...logoUsage ? { logoUsage } : {}
+  };
+}
+function brandDocReader(cacheDir, onSpend) {
+  return async (docs) => {
+    const prompt = brandDocPrompt(docs);
+    const key = createHash("sha256").update(JSON.stringify([PROMPT_VERSION, BRAND_DOC_MODEL, prompt])).digest("hex");
+    const file = path.join(cacheDir, "brand-doc", `${key}.json`);
+    const cached = parseBrandDoc(await readFile(file, "utf8").then(JSON.parse, () => null));
+    if (cached) return cached;
+    const spent = [];
+    const answer = await askAboutText(BRAND_DOC_MODEL, prompt, (u) => onSpend ? onSpend(u) : spent.push(u), {
+      timeoutMs: TIMEOUT_MS,
+      request: REQUEST
+    }).catch(() => null);
+    await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+    const reading = parseBrandDoc(answer);
+    if (reading) {
+      await mkdir(path.dirname(file), { recursive: true }).catch(() => void 0);
+      await writeFile(file, JSON.stringify(reading), "utf8").catch(() => void 0);
+    }
+    return reading;
+  };
+}
+var LOGO_FILE = /logo|lockup|wordmark|isotype|isologo/i;
+async function workspaceBrandDocs(root) {
+  const read = (rel) => readFile(path.join(root, rel), "utf8").catch(() => null);
+  const logoFiles = (await readdir(path.join(root, "src", "brand", "logos")).catch(() => [])).filter((f) => /\.(png|jpe?g|webp|svg)$/i.test(f) && LOGO_FILE.test(f)).sort();
+  return { brandMd: await read("src/brand/BRAND.md"), companyMd: await read("COMPANY.md"), logoFiles };
+}
+async function readWorkspaceBrandDoc(root, opts = {}) {
+  const docs = await workspaceBrandDocs(root);
+  if (!docs.brandMd?.trim() && !docs.companyMd?.trim()) return null;
+  const read = opts.read ?? brandDocReader(path.join(root, "canvas", ".cache"), opts.onSpend);
+  return await read(docs).catch(() => null);
+}
+
+export {
+  LOGO_FILE,
+  readWorkspaceBrandDoc
+};
+//# sourceMappingURL=chunk-3YJNSUNF.js.map