@koda-sl/baker-cli 0.545.0 → 0.546.0-dev.e8b0ca6de

package/dist/schedule-BODZ6DED.js

@@ -0,0 +1,64 @@
+import {
+  reportError,
+  reportInvalid
+} from "./chunk-F4QA4J2S.js";
+import {
+  testimonialSourceRefreshIntervalSchema,
+  testimonialSourcesScheduleRequestSchema
+} from "./chunk-3S3TVLAV.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-BNO3EFGR.js";
+import {
+  apiPost
+} from "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/testimonials/sources/schedule.ts
+import { defineCommand } from "citty";
+var INTERVALS = testimonialSourceRefreshIntervalSchema.options.join("|");
+registerSchema({
+  command: "testimonials.sources.schedule",
+  description: "Set how often a review source imports its new reviews on its own.",
+  args: {
+    id: { type: "string", description: "Source id from `testimonials sources list`", required: true },
+    every: { type: "string", description: `Auto-sync cadence: ${INTERVALS}`, required: true }
+  }
+});
+var scheduleCommand = defineCommand({
+  meta: {
+    name: "schedule",
+    description: "Set a review source's auto-sync cadence.\n\nExample: baker testimonials sources schedule <source-id> --every monthly"
+  },
+  args: {
+    id: { type: "positional", description: "Source id from `testimonials sources list`", required: true },
+    every: { type: "string", description: INTERVALS, required: true }
+  },
+  run: async ({ args }) => {
+    const parsed = testimonialSourcesScheduleRequestSchema.safeParse({
+      id: String(args.id ?? ""),
+      every: String(args.every ?? "").toLowerCase()
+    });
+    if (!parsed.success) reportInvalid(parsed.error.issues[0]);
+    try {
+      const data = await apiPost("/api/testimonials/sources/schedule", parsed.data);
+      writeJson({ ok: true, data: { id: data.id, autoSync: parsed.data.every } });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  scheduleCommand
+};
+//# sourceMappingURL=schedule-BODZ6DED.js.map

package/dist/scheduled-agents-GZEB2B25.js

@@ -0,0 +1,55 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/scheduled-agents/index.ts
+import { defineCommand } from "citty";
+var scheduledAgentsCommand = defineCommand({
+  meta: {
+    name: "scheduled-agents",
+    description: `Manage Scheduled agents. Subcommands: list, get, history, triggers, targets, create, update, delete, unstage, run.
+
+A scheduled agent is a **trigger** and a **prompt**, and nothing else. The trigger is the whole of the "when" \u2014 a time, a cadence, a call-in from another tool, an event arriving, a Form being submitted, an A/B test finishing, a Task closing. The prompt is the whole of the "what": when the trigger fires, a Session opens with that prompt and does the job. There is no Task in between.
+
+Keep the prompt short: the outcome, the exact \`baker\` commands (or tools) to run with their flags, and what to report. A few lines, not an essay \u2014 the run already knows how to work.
+
+Start with \`triggers\`: a time of day is only the most obvious way to start one, and most of what a marketer actually wants is a reaction to something. Then \`targets\` to point it at one thing \u2014 this Task, that agent's publish, one competitor \u2014 rather than every one.
+
+Drafts: create/update/delete stage changes on BAKER_CHAT_ID and apply when the chat is published; \`unstage\` takes one back before then. \`run\` fires a published item immediately. \`get\` on a published item says who its runs act as and which tools they load (runsAs). \`history\` lists every time it was triggered \u2014 the runs, and the firings that did not run and why.
+
+For a condition no field rule can express ("only leads from real companies"), add \`--ai-check "<condition in plain words>"\`: AI judges what arrived against it, after the --when rules.
+
+Publishing every run's work unreviewed is the user's switch, on the item \u2014 not a flag. Ask them to turn it on after this chat is published.
+
+Examples:
+  baker scheduled-agents triggers
+  baker scheduled-agents targets --trigger task.claimed --field taskId
+  baker scheduled-agents list
+  baker scheduled-agents get <id-or-temp_agent_id>
+  baker scheduled-agents history <id> --only skipped --full
+  baker scheduled-agents create --name "Weekly search check" --description "..." --prompt "Run \`baker gsc query --preset top-queries --days 28\`. Report the five queries that lost the most clicks and the page each ranks with." --cron "0 9 * * MON"
+  baker scheduled-agents create --name "Chase a new lead" --description "..." --prompt "..." --trigger form.submitted --form quote
+  baker scheduled-agents create --name "Chase company leads" --description "..." --prompt "..." --trigger form.submitted --form demo --ai-check "the person writes on behalf of a company, not as a student or for personal use"
+  baker scheduled-agents create --name "Welcome the first signup" --description "..." --prompt "..." --trigger event.received --event signup --occurrences 1
+  baker scheduled-agents create --name "Check the SEO agent's work" --description "..." --prompt "..." --trigger session.published --agent <id>
+  baker scheduled-agents update <id-or-temp_agent_id> --enabled false
+  baker scheduled-agents delete <id-or-temp_agent_id>
+  baker scheduled-agents unstage <id-or-temp_agent_id> [--index <n>]
+  baker scheduled-agents run <id>
+Full guide: __tooling__/docs/tools/baker/scheduled-agents.md`
+  },
+  subCommands: {
+    list: () => import("./list-WMF25FUC.js").then((m) => m.listCommand),
+    get: () => import("./get-NR34JBHK.js").then((m) => m.getCommand),
+    history: () => import("./history-IMHDQLXW.js").then((m) => m.historyCommand),
+    triggers: () => import("./triggers-QBG5VN5O.js").then((m) => m.triggersCommand),
+    targets: () => import("./targets-AOE2FDDM.js").then((m) => m.targetsCommand),
+    create: () => import("./create-EQSXPFUS.js").then((m) => m.createCommand),
+    update: () => import("./update-RW5T53RB.js").then((m) => m.updateCommand),
+    delete: () => import("./delete-Q3DM3BTX.js").then((m) => m.deleteCommand),
+    unstage: () => import("./unstage-EU6YHHDA.js").then((m) => m.unstageCommand),
+    run: () => import("./run-OPSLEKBZ.js").then((m) => m.runCommand)
+  }
+});
+export {
+  scheduledAgentsCommand
+};
+//# sourceMappingURL=scheduled-agents-GZEB2B25.js.map

package/dist/schema-I54DIUTV.js

@@ -0,0 +1,135 @@
+import {
+  describeSlots
+} from "./chunk-RLTFA2YN.js";
+import "./chunk-XN77O7GB.js";
+import {
+  FLOW_CATALOG,
+  FLOW_FORM_FIELD_TYPES,
+  flowCatalogEntry,
+  flowCatalogTypes,
+  flowNodeTriggers
+} from "./chunk-3S3TVLAV.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-BNO3EFGR.js";
+import "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/schema.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "flows.schema",
+  description: "The shape of one node or side-effect type: a pasteable skeleton, who fills each part, and the reference file with the craft. Start here before authoring anything in a form's _data.json.",
+  args: {
+    kind: { type: "positional", description: "node | side-effect. Omit to list both vocabularies.", required: false },
+    type: { type: "positional", description: "The type, e.g. customForm or googleSpreadsheet", required: false }
+  }
+});
+var KINDS = ["node", "side-effect"];
+function triggerReport(triggers) {
+  return {
+    fires: triggers.completion,
+    available: triggers.available,
+    ...triggers.why ? { why: triggers.why } : {}
+  };
+}
+function triggerHints(triggers) {
+  if (!triggers) return [];
+  if (!triggers.completion) return [`No side effect can be added to this step as it stands: ${triggers.why}`];
+  const others = triggers.available.filter((id) => id !== triggers.completion);
+  return [
+    `A side effect on this step carries \`triggerId: "${triggers.completion}"\`, and \`baker flows add-side-effect\` writes it for you. The trigger belongs to the STEP, not to the side-effect type: one that does not match is valid, ships, and never runs.` + (others.length > 0 ? ` Other moments this step raises: ${others.join(", ")}.` : "")
+  ];
+}
+var schemaCommand = defineCommand({
+  meta: {
+    name: "schema",
+    description: "Show a node or side-effect type's shape. Start here: baker flows schema node customForm \xB7 baker flows schema side-effect googleSpreadsheet \xB7 baker flows schema (lists both)"
+  },
+  args: {
+    kind: { type: "positional", description: "node | side-effect", required: false },
+    type: { type: "positional", description: "The type name", required: false }
+  },
+  run: ({ args }) => {
+    const kind = args.kind ? String(args.kind) : void 0;
+    const type = args.type ? String(args.type) : void 0;
+    if (!kind) {
+      writeJson({
+        ok: true,
+        data: {
+          node: flowCatalogTypes("node"),
+          "side-effect": flowCatalogTypes("side-effect"),
+          formFieldTypes: FLOW_FORM_FIELD_TYPES
+        },
+        hints: [
+          "baker flows schema node <type> \xB7 baker flows schema side-effect <type>",
+          "`hubspot` is in both lists and they are different things: the node embeds a form on the page, the side effect fires a behavioural event.",
+          "formFieldTypes are the `fieldtype` values INSIDE a customForm \u2014 a third vocabulary, not node types."
+        ]
+      });
+      return;
+    }
+    if (!KINDS.includes(kind)) {
+      writeJson({
+        ok: false,
+        error: { code: "VALIDATION_ERROR", message: `Unknown kind "${kind}".`, fix: `Expected: ${KINDS.join(" | ")}` }
+      });
+      process.exit(1);
+    }
+    if (!type) {
+      writeJson({
+        ok: true,
+        data: { kind, types: flowCatalogTypes(kind) },
+        hints: [`baker flows schema ${kind} <type>`]
+      });
+      return;
+    }
+    const entry = flowCatalogEntry(kind, type);
+    if (!entry) {
+      const alternate = FLOW_CATALOG.find((candidate) => candidate.type === type);
+      writeJson({
+        ok: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `No ${kind} type "${type}".`,
+          fix: alternate ? `"${type}" is a ${alternate.kind} type, not a ${kind} type. Try: baker flows schema ${alternate.kind} ${type}` : `Known ${kind} types: ${flowCatalogTypes(kind).join(", ")}`
+        }
+      });
+      process.exit(1);
+    }
+    const mappable = kind === "side-effect" ? describeSlots(type) : [];
+    const triggers = kind === "node" ? flowNodeTriggers(entry.skeleton.nodeData) : null;
+    writeJson({
+      ok: true,
+      data: {
+        ...entry,
+        ...mappable.length > 0 ? { mappable } : {},
+        ...triggers ? { triggers: triggerReport(triggers) } : {}
+      },
+      hints: [
+        `Full schema, gotchas and a worked example: ${entry.reference}`,
+        ...triggerHints(triggers),
+        ...mappable.length > 0 ? [
+          `Mappable with \`baker flows map\`: ${mappable.map((slot) => slot.slot).join(", ")}. Run \`baker flows map <slug> --side-effect <id>\` with no --map to see the legal keys for one you already have.`
+        ] : [],
+        ...entry.owners ? [
+          `You author everything except: ${Object.entries(entry.owners).filter(([, owner]) => owner !== "agent").map(([key, owner]) => `${key} (${owner})`).join(", ")}`
+        ] : []
+      ].filter(Boolean)
+    });
+  }
+});
+export {
+  schemaCommand
+};
+//# sourceMappingURL=schema-I54DIUTV.js.map

package/dist/schema-U6GAKTQZ.js

@@ -0,0 +1,121 @@
+import {
+  agentProfile,
+  offers
+} from "./chunk-RQOSSYVH.js";
+import "./chunk-E54435XT.js";
+import {
+  commandTree,
+  findSchema,
+  listSchemas,
+  spellingKey,
+  usageArgsOf,
+  usageLine,
+  writeJson
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/schema.ts
+import { defineCommand } from "citty";
+function narrowToFamily(commandName, available) {
+  const segments = commandName.split(".");
+  const prefix = segments[0] === "ads" && segments[1] ? `ads.${segments[1]}.` : `${segments[0]}.`;
+  const siblings = available.filter((name) => name.startsWith(prefix));
+  return siblings.length > 0 ? siblings : available;
+}
+function commandOfSchema(root, name) {
+  let command = root;
+  const path = [];
+  for (const segment of name.split(".")) {
+    const subCommands = command.subCommands;
+    if (!subCommands || typeof subCommands !== "object") return null;
+    const found = Object.entries(subCommands).find(([key]) => spellingKey(key) === spellingKey(segment));
+    if (!found?.[1] || typeof found[1] !== "object") return null;
+    path.push(found[0]);
+    command = found[1];
+  }
+  return { command, path: path.join(" ") };
+}
+function asTheCommandReadsIt(schema, root) {
+  const found = commandOfSchema(root, schema.command);
+  if (!found) return schema;
+  const declared = usageArgsOf(found.command).filter((arg) => arg.positional);
+  const place = (name) => declared.findIndex((arg) => spellingKey(arg.name) === spellingKey(name));
+  const listed = Object.entries(schema.args).map(([name, arg]) => [
+    name,
+    place(name) >= 0 ? { ...arg, type: "positional" } : arg
+  ]);
+  const missing = declared.filter((arg) => !listed.some(([name]) => spellingKey(name) === spellingKey(arg.name))).map((arg) => [
+    arg.name,
+    { type: "positional", description: arg.description, required: arg.required }
+  ]);
+  const args = Object.fromEntries([...listed, ...missing]);
+  const usageArgs = Object.entries(args).map(([name, arg]) => ({
+    name,
+    positional: arg.type === "positional",
+    required: arg.required,
+    boolean: arg.type === "boolean"
+  }));
+  const usage = usageLine([found.path, subCommandWord(found.command)].filter(Boolean).join(" "), [
+    ...usageArgs.filter((arg) => arg.positional).sort((a, b) => place(a.name) - place(b.name)),
+    ...usageArgs.filter((arg) => !arg.positional)
+  ]);
+  return { command: schema.command, description: schema.description, usage, args };
+}
+function subCommandWord(command) {
+  const subCommands = command.subCommands;
+  const names = subCommands && typeof subCommands === "object" ? Object.keys(subCommands) : [];
+  if (names.length === 0) return "";
+  const choice = names.join("|");
+  return command.run === void 0 && command.default === void 0 ? `<${choice}>` : `[${choice}]`;
+}
+var schemaCommand = defineCommand({
+  meta: {
+    name: "schema",
+    description: "Inspect command argument schemas (for AI agent introspection). Lists all commands if no argument given. Example: baker schema images search (or images.search)"
+  },
+  args: {
+    command: {
+      type: "positional",
+      description: "Command path, as typed (images list) or dotted (images.list). Omit to list all.",
+      required: false
+    }
+  },
+  run: ({ args }) => {
+    const words = args._.filter((word) => typeof word === "string" && word.length > 0);
+    if (words.length === 0) {
+      const profile = agentProfile();
+      const schemas = listSchemas().filter((name) => offers(profile, name.replaceAll(".", " ")));
+      writeJson({ ok: true, data: { commands: schemas } });
+      return;
+    }
+    const commandName = words.join(".");
+    const schema = findSchema(words);
+    if (!schema) {
+      const all = listSchemas();
+      const available = narrowToFamily(commandName, all);
+      const segments = commandName.split(".");
+      const family = segments[0] === "ads" && segments[1] ? `ads-${segments[1]}` : segments[0];
+      const scope = available.length < all.length ? ` in the "${family}" family` : "";
+      writeJson({
+        ok: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `Schema "${commandName}" not found. Available${scope}: ${available.join(", ")}`,
+          fix: {
+            action: `Run the command with --help for exact args, and read __tooling__/docs/tools/baker/${family}.md`,
+            explanation: "Not every command registers a schema; --help and the family doc are the ground truth for those."
+          }
+        }
+      });
+      process.exit(1);
+    }
+    const tree = commandTree();
+    writeJson({ ok: true, data: tree ? asTheCommandReadsIt(schema, tree) : schema });
+  }
+});
+export {
+  asTheCommandReadsIt,
+  narrowToFamily,
+  schemaCommand
+};
+//# sourceMappingURL=schema-U6GAKTQZ.js.map

package/dist/search-IJ745GV3.js

@@ -0,0 +1,177 @@
+import {
+  measureEmptyCorpus
+} from "./chunk-4KCYP423.js";
+import {
+  activeFilterFlags
+} from "./chunk-Q6ULQMWG.js";
+import {
+  testimonialSourceTypeSchema
+} from "./chunk-3S3TVLAV.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-BNO3EFGR.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import {
+  registerSchema,
+  testimonialNormalizer,
+  writeJson,
+  writeOutput
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/testimonials/search.ts
+import { defineCommand } from "citty";
+var FILTER_FLAGS = ["source", "rating-min", "rating-max", "status", "sentiment", "language", "tags"];
+function languageBiasHint(results, requestedLanguage) {
+  if (requestedLanguage) {
+    return null;
+  }
+  const withLang = results.filter((r) => typeof r.language === "string" && r.language.length > 0);
+  if (withLang.length < 3) {
+    return null;
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of withLang) {
+    const lang = r.language;
+    counts.set(lang, (counts.get(lang) ?? 0) + 1);
+  }
+  const [topLang, topCount] = [...counts.entries()].sort((a, b) => b[1] - a[1])[0] ?? ["", 0];
+  if (topLang && topCount / withLang.length >= 0.8) {
+    return `Results skew ${topLang} (${topCount}/${withLang.length}). If you're sourcing quotes for a specific market, pass --language <code> (e.g. --language en) so the ad's language matches its audience.`;
+  }
+  return null;
+}
+registerSchema({
+  command: "testimonials.search",
+  description: "Search testimonials by text query. Uses hybrid BM25 + vector + reranking.",
+  args: {
+    query: { type: "string", description: "Search query text", required: true },
+    limit: { type: "number", description: "Maximum results to return", required: false, default: 10 },
+    source: {
+      type: "string",
+      description: `Filter by source: ${testimonialSourceTypeSchema.options.join("|")}`,
+      required: false,
+      enum: [...testimonialSourceTypeSchema.options]
+    },
+    "rating-min": { type: "number", description: "Minimum star rating (1-5)", required: false },
+    "rating-max": { type: "number", description: "Maximum star rating (1-5)", required: false },
+    status: {
+      type: "string",
+      description: "Filter by status: pending|processing|ready|error",
+      required: false,
+      enum: ["pending", "processing", "ready", "error"]
+    },
+    sentiment: {
+      type: "string",
+      description: "Filter: positive|neutral|negative",
+      required: false,
+      enum: ["positive", "neutral", "negative"]
+    },
+    language: { type: "string", description: "Filter by language code (e.g. en, es)", required: false },
+    tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
+  }
+});
+function buildSearchRequest(query, args) {
+  const body = { query };
+  if (args.limit !== void 0) {
+    body.limit = Number(args.limit);
+  }
+  if (args.source) {
+    body.source = args.source;
+  }
+  if (args["rating-min"] !== void 0) {
+    body.rating_min = Number(args["rating-min"]);
+  }
+  if (args["rating-max"] !== void 0) {
+    body.rating_max = Number(args["rating-max"]);
+  }
+  if (args.status) {
+    body.status = args.status;
+  }
+  if (args.sentiment) {
+    body.sentiment = args.sentiment;
+  }
+  if (args.language) {
+    body.language = args.language;
+  }
+  if (args.tags) {
+    body.tags = args.tags.split(",").filter(Boolean);
+  }
+  return body;
+}
+var searchCommand = defineCommand({
+  meta: {
+    name: "search",
+    description: "Semantic search testimonials by text query. Uses hybrid BM25 + vector + reranking. Example: baker testimonials search 'great service' --rating-min 4"
+  },
+  args: {
+    query: { type: "positional", description: "Search query text", required: false },
+    limit: { type: "string", description: "Max results (default 10)", required: false },
+    source: {
+      type: "string",
+      description: `Filter by source: ${testimonialSourceTypeSchema.options.join("|")}`,
+      required: false
+    },
+    "rating-min": { type: "string", description: "Minimum star rating (1-5)", required: false },
+    "rating-max": { type: "string", description: "Maximum star rating (1-5)", required: false },
+    status: { type: "string", description: "Filter by status: pending|processing|ready|error", required: false },
+    sentiment: { type: "string", description: "Filter: positive|neutral|negative", required: false },
+    language: { type: "string", description: "Filter by language code (e.g. en, es)", required: false },
+    tags: { type: "string", description: "Comma-separated tags to filter by", required: false },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const query = args.query;
+      if (!query) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Search query is required" } });
+        process.exit(1);
+      }
+      const body = buildSearchRequest(query, args);
+      const data = await apiPost("/api/testimonials/search", body);
+      const languageHint = languageBiasHint(data, body.language);
+      const { hints: emptyHints, empty } = await measureEmptyCorpus({
+        command: "search",
+        resultCount: data.length,
+        activeFilters: activeFilterFlags(args, FILTER_FLAGS)
+      });
+      const hints = [...emptyHints, ...languageHint ? [languageHint] : []];
+      const outputFormat = args.output || "json";
+      writeOutput(
+        { ok: true, data, ...empty ? { meta: { empty } } : {}, ...hints.length > 0 ? { hints } : {} },
+        outputFormat,
+        args.fields ? args.fields.split(",") : void 0,
+        args.full,
+        testimonialNormalizer
+      );
+      if (outputFormat !== "json") {
+        for (const hint of hints) {
+          process.stderr.write(`${hint}
+`);
+        }
+      }
+    } 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 {
+  searchCommand
+};
+//# sourceMappingURL=search-IJ745GV3.js.map

package/dist/select-WZJCQW4A.js

@@ -0,0 +1,110 @@
+import {
+  versionOf
+} from "./chunk-XK2ZJ6CI.js";
+import "./chunk-MONZLJWO.js";
+import "./chunk-7UFV6H7J.js";
+import "./chunk-PZEPUBAS.js";
+import "./chunk-6REXNFPV.js";
+import "./chunk-EKX37C3T.js";
+import "./chunk-LDFM37DM.js";
+import "./chunk-EZVW3KAW.js";
+import "./chunk-LDMN6RE6.js";
+import "./chunk-JYXERSEO.js";
+import "./chunk-C4EE6LIF.js";
+import "./chunk-P6744QO6.js";
+import "./chunk-3EUITH4J.js";
+import "./chunk-UYUH5XNV.js";
+import "./chunk-JDBZCUTY.js";
+import "./chunk-P6FMQHJJ.js";
+import "./chunk-G6XKD7QE.js";
+import "./chunk-NGQ5J4FV.js";
+import "./chunk-VWOKPC3T.js";
+import "./chunk-BGT5ZA4L.js";
+import "./chunk-E5H7JIWB.js";
+import "./chunk-GCZK4BMB.js";
+import "./chunk-Q6LCL67T.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-4IRJ5JXA.js";
+import "./chunk-XU6XQPNM.js";
+import "./chunk-B3CDNANO.js";
+import "./chunk-F3CZFUXZ.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-JF2XP76K.js";
+import "./chunk-SYLPRIFM.js";
+import "./chunk-XBR7TSZN.js";
+import "./chunk-DGUN7FUH.js";
+import {
+  creativesSelectRequestSchema
+} from "./chunk-3S3TVLAV.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-BNO3EFGR.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/select.ts
+import { defineCommand } from "citty";
+var DESCRIPTION = `Choose the version of a creative to keep, and optionally which of its options, only when the user says to keep this version in this chat. The creative shows that version as the chosen one, and the choice counts as the user's approval. A version you render after it replaces it when the chat is published (the user saw that one last). It does not save the image to their library (that is baker creatives publish) and puts nothing into an ad.
+Start here: baker creatives select --slug spring-offer
+Only some options of a version that made several: --options "ugc,2" (labels or numbers). Naming options again replaces the earlier pick.`;
+var ARGS = {
+  slug: { type: "string", description: "The creative: its folder name under src/creatives/.", required: true },
+  run: {
+    type: "string",
+    description: "The version to keep: its canvas run id (r_\u2026) Left out, the version the creative shows now (its last render).",
+    required: false
+  },
+  options: {
+    type: "string",
+    description: 'Keep only these options of the version, comma-separated: labels ("ugc"), numbers ("2") or slots. Left out, the whole version.',
+    required: false
+  }
+};
+registerSchema({ command: "creatives.select", description: DESCRIPTION, args: ARGS });
+function fail(code, message) {
+  writeJson({ ok: false, error: { code, message } });
+  process.exit(1);
+}
+var selectCommand = defineCommand({
+  meta: { name: "select", description: DESCRIPTION },
+  args: ARGS,
+  run: async ({ args }) => {
+    const options = typeof args.options === "string" ? args.options.split(",").map((option) => option.trim()).filter((option) => option.length > 0) : [];
+    const parsed = creativesSelectRequestSchema.safeParse({
+      slug: args.slug,
+      runId: await versionOf(String(args.slug), args.run).then(
+        (run) => run ?? fail("VALIDATION_ERROR", "--run: this creative has no rendered version here; name one (r_\u2026).")
+      ),
+      ...options.length > 0 ? { options } : {}
+    });
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      fail("VALIDATION_ERROR", `--${String(issue?.path[0] ?? "args")}: ${issue?.message ?? "invalid"}`);
+    }
+    try {
+      const response = await apiPost("/api/creatives/select", parsed.data);
+      writeJson(response);
+    } catch (err) {
+      if (err instanceof ApiError) fail(err.code, err.message);
+      fail("INTERNAL_ERROR", "Unexpected error");
+    }
+  }
+});
+export {
+  selectCommand
+};
+//# sourceMappingURL=select-WZJCQW4A.js.map