@koda-sl/baker-cli 0.502.0 → 0.504.0-dev.239e52d65

package/dist/chunk-YHF7H3Q2.js

@@ -0,0 +1,191 @@
+import {
+  readRenderState,
+  recordSeen
+} from "./chunk-LSZY7Q7R.js";
+import {
+  GLOBAL_PROMPT_FILE,
+  ideaBaseline,
+  isVideoBlueprint,
+  readIdeaAnchor,
+  recordedChanges
+} from "./chunk-JKHRDM45.js";
+import {
+  loadCompositionMeta
+} from "./chunk-2FRBKADB.js";
+import {
+  parseRefExpr
+} from "./chunk-F6DDX2RT.js";
+import {
+  resolveAdaptFormats
+} from "./chunk-UQA3ASVK.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+
+// src/commands/canvas/output-ratio.ts
+import { readFile } from "fs/promises";
+import path from "path";
+function definitionFormats(markdown) {
+  const front = markdown.match(/^---\n([\s\S]*?)\n---/)?.[1];
+  if (!front) return [];
+  const clean = (s) => s.trim().replace(/^["']|["']$/g, "");
+  const flow = front.match(/^formats:\s*\[([^\]]*)\]/m);
+  if (flow) return (flow[1] ?? "").split(",").map(clean).filter(Boolean);
+  const block = front.match(/^formats:\s*\n((?:\s+-\s+.*\n?)+)/m);
+  if (!block) return [];
+  return (block[1] ?? "").split("\n").map((l) => l.replace(/^\s+-\s+/, "")).map(clean).filter(Boolean);
+}
+function reduce(width, height) {
+  const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+  const d = gcd(width, height);
+  return `${width / d}:${height / d}`;
+}
+async function ratiosOf(nodes, id, seen) {
+  const node = nodes.get(id);
+  if (!node || seen.has(id)) return null;
+  seen.add(id);
+  const p = node.params ?? {};
+  switch (node.type) {
+    case "image_generate":
+      return typeof p.aspect_ratio === "string" ? [p.aspect_ratio] : null;
+    case "image_aspect_adapt":
+      return [...resolveAdaptFormats(p)];
+    case "hyperframe_snapshot": {
+      if (typeof p.composition !== "string") return null;
+      const meta = await loadCompositionMeta(p.composition).catch(() => null);
+      return meta ? [reduce(meta.width, meta.height)] : null;
+    }
+    case "collect": {
+      const images = node.inputs?.images;
+      if (!Array.isArray(images)) return null;
+      const out = [];
+      for (const entry of images) {
+        const ref = typeof entry === "string" ? parseRefExpr(entry) : null;
+        if (!ref || ref.kind !== "ref") return null;
+        const upstream = await ratiosOf(nodes, ref.nodeId, seen);
+        if (!upstream) return null;
+        out.push(ref.index !== void 0 && upstream.length > 1 ? upstream[ref.index] ?? "" : upstream[0] ?? "");
+      }
+      return out.filter(Boolean);
+    }
+    default:
+      return null;
+  }
+}
+async function producedRatios(canvas) {
+  const c = canvas;
+  if (!Array.isArray(c?.nodes) || typeof c?.output?.node !== "string") return null;
+  const nodes = new Map(c.nodes.flatMap((n) => typeof n.id === "string" ? [[n.id, n]] : []));
+  return ratiosOf(nodes, c.output.node, /* @__PURE__ */ new Set());
+}
+function value(ratio) {
+  const [w, h] = ratio.split(":").map(Number);
+  return w && h ? w / h : null;
+}
+function outputRatioWarnings(declared, produced) {
+  if (!produced || produced.length === 0) return [];
+  const shapes = produced.flatMap((r) => value(r) ?? []);
+  return declared.flatMap((format) => {
+    const want = value(format);
+    if (want === null || shapes.some((s) => Math.abs(s / want - 1) <= 0.02)) return [];
+    return [
+      {
+        path: "output",
+        code: "OUTPUT_RATIO_MISMATCH",
+        severity: "warning",
+        message: `_definition.md declares ${format}, but this canvas delivers ${produced.join(", ")}. A ${format} placement would get the wrong shape: re-scaffold with that format, or fix the formats the creative declares.`
+      }
+    ];
+  });
+}
+async function outputRatioWarningsFor(canvas, canvasPath) {
+  const definition = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8").catch(() => null);
+  if (!definition) return [];
+  return outputRatioWarnings(definitionFormats(definition), await producedRatios(canvas));
+}
+
+// src/commands/canvas/shown-version.ts
+import { z } from "zod";
+var ShownResponse = z.object({
+  data: z.object({
+    runId: z.string(),
+    sourceSha: z.string().optional(),
+    createdAt: z.number(),
+    canvasSnapshotUrl: z.string().optional()
+  })
+});
+var SnapshotEntry = z.object({ path: z.string(), url: z.string() });
+var SnapshotFiles = z.object({ canvas: SnapshotEntry.optional(), files: z.array(SnapshotEntry) });
+var HISTORY = {
+  shown: async (slug) => ShownResponse.parse(await apiPost("/api/creatives/run", { slug })).data,
+  file: async (url) => {
+    const res = await fetch(url);
+    return res.ok ? res.json() : null;
+  },
+  text: async (url) => {
+    const res = await fetch(url);
+    return res.ok ? res.text() : null;
+  }
+};
+async function shownVersion(canvasRoot, slug, sources = HISTORY) {
+  const here = await readRenderState(canvasRoot, slug);
+  if (here.rendered) return here;
+  const run = await sources.shown(slug).catch(() => null);
+  if (!run) return here;
+  const drawn = run.canvasSnapshotUrl ? await drawnFiles(run.canvasSnapshotUrl, sources) : {};
+  return {
+    ...here,
+    rendered: { sourceSha: run.sourceSha ?? "", runId: run.runId, at: run.createdAt },
+    ...drawn.prompt !== void 0 ? { prompt: drawn.prompt } : {},
+    ...drawn.definition !== void 0 ? { definition: drawn.definition } : {},
+    ...drawn.video ? { video: drawn.video } : {}
+  };
+}
+async function drawnFiles(manifestUrl, sources) {
+  const manifest = SnapshotFiles.safeParse(await sources.file(manifestUrl).catch(() => null));
+  const files = manifest.success ? manifest.data.files : [];
+  const urlOf = (file) => files.find((f) => f.path === file)?.url;
+  const promptUrl = urlOf(GLOBAL_PROMPT_FILE);
+  const definitionUrl = urlOf("_definition.md");
+  const read = (url) => url ? sources.file(url).catch(() => null) : Promise.resolve(null);
+  const sceneEntries = files.filter((f) => /^scenes\/[^/]+\.json$/.test(f.path)).sort((a, b) => a.path.localeCompare(b.path));
+  const [prompt, definition, scenes, canvas, adSpec] = await Promise.all([
+    read(promptUrl),
+    definitionUrl ? sources.text(definitionUrl).catch(() => null) : null,
+    Promise.all(sceneEntries.map((f) => read(f.url))),
+    read(manifest.success ? manifest.data.canvas?.url : void 0),
+    read(urlOf("ad.spec.json"))
+  ]);
+  return {
+    ...prompt !== null && prompt !== void 0 ? { prompt } : {},
+    ...typeof definition === "string" ? { definition } : {},
+    video: { scenes: scenes.filter((s) => s !== null), canvas, adSpec }
+  };
+}
+
+// src/commands/canvas/shown-anchor.ts
+async function shownBaseline(opts) {
+  const state = await readRenderState(opts.canvasRoot, opts.slug);
+  const known = opts.turnId !== void 0 && state.seen?.turnId === opts.turnId;
+  let fallback;
+  if (!known && !state.anchor) {
+    const shown = opts.shown ?? await shownVersion(opts.canvasRoot, opts.slug, opts.sources);
+    if (shown.rendered && shown.prompt !== void 0) {
+      const video = typeof shown.prompt === "object" && shown.prompt !== null && isVideoBlueprint(shown.prompt);
+      const recorded = shown.video;
+      const unrecorded = video && (!recorded || recorded.canvas === null || recorded.canvas === void 0);
+      const anchor = unrecorded ? void 0 : (await readIdeaAnchor(opts.creativeDir, { spec: shown.prompt, ...video && recorded ? { recorded } : {} }))?.anchor;
+      if (anchor) fallback = { ...anchor, changes: shown.definition ? recordedChanges(shown.definition) : [] };
+    }
+  }
+  const { baseline, seen } = ideaBaseline(state, opts.turnId, fallback);
+  if (seen && opts.record) await recordSeen(opts.canvasRoot, opts.slug, seen);
+  return baseline ? { baseline } : {};
+}
+
+export {
+  outputRatioWarningsFor,
+  shownVersion,
+  shownBaseline
+};
+//# sourceMappingURL=chunk-YHF7H3Q2.js.map

package/dist/chunk-YLQWWLCW.js

@@ -0,0 +1,219 @@
+import {
+  bareAccountId,
+  failWriteValidation,
+  numberFlag,
+  requireTarget,
+  stageOp,
+  stageOps
+} from "./chunk-S335LT4B.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/ads/meta/asset-writes.ts
+import { defineCommand } from "citty";
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads meta draft`.";
+var accountArg = { type: "string", description: "Meta ad account ID (act_123)" };
+var schemaId = (what) => ({ type: "positional", description: what, required: true });
+function command(input) {
+  registerSchema({
+    command: input.schema,
+    description: input.schemaDescription,
+    args: Object.fromEntries(
+      Object.entries(input.args).map(([key, arg]) => [
+        key,
+        { type: arg.type, description: arg.description, required: arg.required === true }
+      ])
+    )
+  });
+  return defineCommand({
+    meta: { name: input.name, description: `${input.description} ${STAGED_NOTE}` },
+    args: input.args,
+    run: async ({ args, rawArgs }) => {
+      await input.run(args, rawArgs);
+    }
+  });
+}
+var creativesDeleteCommand = command({
+  schema: "ads.meta.creatives.delete",
+  name: "delete",
+  description: "Stage deleting an ad creative. Meta deletes only a creative no ad runs \u2014 repoint or delete the ad first. Permanent.",
+  schemaDescription: "Stage deleting a Meta ad creative (status DELETED) \u2014 applied at publish, permanent. Meta refuses a creative an ad still runs.",
+  args: { id: { type: "positional", description: "Creative id", required: true }, "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "adCreative.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "creative"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var mediaDeleteCommand = command({
+  schema: "ads.meta.media.delete",
+  name: "delete",
+  description: "Stage taking an image out of the ad account's image library, by its hash (`baker ads meta images`), or one of its videos by id (`--video-id`, from `baker ads meta media`). Meta refuses an image a creative still uses.",
+  schemaDescription: "Stage deleting an image from a Meta ad account's image library by hash, or a video from its video library by id \u2014 applied at publish. Meta refuses an image a creative uses.",
+  args: {
+    "account-id": accountArg,
+    "image-hash": { type: "string", description: "The image's hash" },
+    "video-id": { type: "string", description: "Or a video of the ad account, by id" }
+  },
+  run: async (args) => {
+    const imageHash = typeof args["image-hash"] === "string" ? args["image-hash"] : void 0;
+    const videoId = typeof args["video-id"] === "string" ? args["video-id"] : void 0;
+    if (imageHash === void 0 === (videoId === void 0)) {
+      failWriteValidation("pass --image-hash (from `baker ads meta images`) or --video-id \u2014 one of them");
+    }
+    await stageOp({ kind: "media.delete", accountId: bareAccountId(args), payload: { imageHash, videoId } });
+  }
+});
+var customConversionsUpdateCommand = command({
+  schema: "ads.meta.custom-conversions.update",
+  name: "update",
+  description: "Stage renaming a Custom Conversion, its description or its value per conversion. Meta keeps a conversion's rule and event category for good \u2014 a conversion that counts something else is a new one.",
+  schemaDescription: "Stage a change to a Meta Custom Conversion: --name, --description, --value (value per conversion, account currency). The rule and event category cannot change (Meta accepts and ignores them).",
+  args: {
+    id: { type: "positional", description: "Custom conversion id", required: true },
+    "account-id": accountArg,
+    name: { type: "string", description: "New name" },
+    description: { type: "string", description: "New description" },
+    value: { type: "string", description: "Value of one conversion, in the account currency" }
+  },
+  run: async (args) => {
+    const payload = Object.fromEntries(
+      Object.entries({
+        name: args.name,
+        description: args.description,
+        default_conversion_value: numberFlag(args.value, "--value")
+      }).filter(([, value]) => value !== void 0)
+    );
+    await stageOp({
+      kind: "customConversion.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "custom conversion"),
+      payload
+    });
+  }
+});
+var customConversionsDeleteCommand = command({
+  schema: "ads.meta.custom-conversions.delete",
+  name: "delete",
+  description: "Stage deleting a Custom Conversion. Meta archives it: it stops counting and leaves the active list, and still uses one of the account's slots. Ad sets optimizing toward it stop finding conversions.",
+  schemaDescription: "Stage deleting (archiving) a Meta Custom Conversion \u2014 applied at publish. Not reversible; it keeps its slot in the account's cap.",
+  args: { id: schemaId("Custom conversion id"), "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "customConversion.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "custom conversion"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var labelsCreateCommand = command({
+  schema: "ads.meta.labels.create",
+  name: "create",
+  description: 'Stage a new ad label. File things under it with `labels attach <ref> --campaigns \u2026` in the same chat. Example: baker ads meta labels create --name "Q4 launch"',
+  schemaDescription: "Stage a new Meta ad label (created at publish). Returns a meta_temp_* ref `labels attach` takes.",
+  args: { "account-id": accountArg, name: { type: "string", description: "Label name" } },
+  run: async (args) => {
+    await stageOp({ kind: "adLabel.create", accountId: bareAccountId(args), payload: { name: args.name } });
+  }
+});
+var labelsRenameCommand = command({
+  schema: "ads.meta.labels.rename",
+  name: "rename",
+  description: "Stage renaming an ad label.",
+  schemaDescription: "Stage renaming a Meta ad label.",
+  args: { id: schemaId("Label id"), "account-id": accountArg, name: { type: "string", description: "New name" } },
+  run: async (args) => {
+    await stageOp({
+      kind: "adLabel.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "label"),
+      payload: { name: args.name }
+    });
+  }
+});
+var labelsDeleteCommand = command({
+  schema: "ads.meta.labels.delete",
+  name: "delete",
+  description: "Stage deleting an ad label. Everything filed under it keeps running, unlabelled.",
+  schemaDescription: "Stage deleting a Meta ad label \u2014 applied at publish; labelled objects keep running.",
+  args: { id: schemaId("Label id"), "account-id": accountArg },
+  run: async (args) => {
+    await stageOp({
+      kind: "adLabel.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "label"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var LABELLED = [
+  ["campaigns", "campaign.update"],
+  ["adsets", "adSet.update"],
+  ["ads", "ad.update"],
+  ["creatives", "adCreative.update"]
+];
+var targetArgs = {
+  campaigns: { type: "string", description: "Campaign ids (comma-separated or repeated)" },
+  adsets: { type: "string", description: "Ad set ids" },
+  ads: { type: "string", description: "Ad ids" },
+  creatives: {
+    type: "string",
+    description: "Creative ids (live ones \u2014 a creative created in this chat is labelled later)"
+  }
+};
+function idsOf(rawArgs, flag, parsed) {
+  return repeatedValues(rawArgs, flag, parsed).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+}
+async function stageLabelChange(verb, args, rawArgs) {
+  const accountId = bareAccountId(args);
+  const label = requireTarget(args, "label");
+  const targets = LABELLED.flatMap(([flag, kind]) => idsOf(rawArgs, flag, args[flag]).map((id) => ({ kind, id })));
+  if (targets.length === 0) {
+    failWriteValidation("name what to label: --campaigns, --adsets, --ads or --creatives");
+  }
+  await stageOps(
+    targets.map((target) => ({ kind: target.kind, accountId, target: target.id, payload: { [verb]: [label] } }))
+  );
+}
+var labelsAttachCommand = command({
+  schema: "ads.meta.labels.attach",
+  name: "attach",
+  description: "Stage filing campaigns, ad sets, ads or creatives under a label (a label id, or a meta_temp_* ref from `labels create`). Their other labels stay. Example: baker ads meta labels attach 120249 --campaigns 6123,6124",
+  schemaDescription: "Stage adding a Meta ad label to campaigns/ad sets/ads/creatives (--campaigns, --adsets, --ads, --creatives; comma-separated). One staged change per object; other labels kept.",
+  args: { id: schemaId("Label id or meta_temp_* ref"), "account-id": accountArg, ...targetArgs },
+  run: async (args, rawArgs) => {
+    await stageLabelChange("addLabels", args, rawArgs);
+  }
+});
+var labelsDetachCommand = command({
+  schema: "ads.meta.labels.detach",
+  name: "detach",
+  description: "Stage taking a label off campaigns, ad sets, ads or creatives. Their other labels stay.",
+  schemaDescription: "Stage removing a Meta ad label from campaigns/ad sets/ads/creatives (--campaigns, --adsets, --ads, --creatives). Other labels kept.",
+  args: { id: schemaId("Label id"), "account-id": accountArg, ...targetArgs },
+  run: async (args, rawArgs) => {
+    await stageLabelChange("removeLabels", args, rawArgs);
+  }
+});
+
+export {
+  command,
+  creativesDeleteCommand,
+  mediaDeleteCommand,
+  customConversionsUpdateCommand,
+  customConversionsDeleteCommand,
+  labelsCreateCommand,
+  labelsRenameCommand,
+  labelsDeleteCommand,
+  labelsAttachCommand,
+  labelsDetachCommand
+};
+//# sourceMappingURL=chunk-YLQWWLCW.js.map

package/dist/chunk-YPDVWJRL.js

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