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

package/dist/stale-ON4X3SHU.js

@@ -0,0 +1,74 @@
+import {
+  staleCreatives
+} from "./chunk-LSZY7Q7R.js";
+import "./chunk-JKHRDM45.js";
+import "./chunk-OG2UYL6Y.js";
+import "./chunk-VUV3YM35.js";
+import "./chunk-WHBFXR6F.js";
+import "./chunk-DQVI7GCX.js";
+import "./chunk-EKX37C3T.js";
+import "./chunk-2WBQBXFJ.js";
+import "./chunk-AII6BPX4.js";
+import "./chunk-EFPIK64C.js";
+import "./chunk-7EAIRV43.js";
+import "./chunk-GTVCHVPH.js";
+import "./chunk-I5HCVGTV.js";
+import "./chunk-QPESDKZC.js";
+import "./chunk-E44NXCTL.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-EJGAJHLB.js";
+import "./chunk-F6DDX2RT.js";
+import "./chunk-2U5JGBY2.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-Y5G42I2T.js";
+import "./chunk-ELXYZUHU.js";
+import "./chunk-CAD6FIYH.js";
+import "./chunk-UQA3ASVK.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-LNNTHEL7.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-KUV4FMAV.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-C6JPTPPU.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/canvas/stale.ts
+import { defineCommand } from "citty";
+var staleCommand = defineCommand({
+  meta: {
+    name: "stale",
+    description: "List the creatives edited since their last render in this workspace: what the models would be sent (the projected canvas, prompt.json without its `reference`/`source_context`/`notes` bookkeeping, scenes/*.json, the compositions it renders, the formats in _definition.md) no longer matches what the last completed `baker canvas run` drew, so the preview shows an older creative. Reformatting a file is not an edit. Read-only, offline and free. During a turn, re-render each one listed that the person should see with `baker canvas run <canvasPath>`. During a publish, never: Publish ships the last version the person was shown. Creatives never rendered here and half-built ones (unfilled [TODO] asset slots) are not listed."
+  },
+  args: {},
+  async run() {
+    const cwd = process.cwd();
+    const stale = await staleCreatives(findWorkspaceRoot(cwd) ?? cwd);
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          data: { stale },
+          ...stale.length > 0 ? { hints: stale.map((c) => `Re-render ${c.slug} before showing it (never during a publish): baker canvas run ${c.canvasPath}`) } : {}
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+export {
+  staleCommand
+};
+//# sourceMappingURL=stale-ON4X3SHU.js.map

package/dist/status-6X2YHFCG.js

@@ -0,0 +1,63 @@
+import {
+  failApi,
+  failValidation
+} from "./chunk-FMBZJ5KY.js";
+import "./chunk-KUV4FMAV.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-C6JPTPPU.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import {
+  getEnv
+} from "./chunk-LGK7UWBN.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/status.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "actions.status",
+  description: "Resolve one or more Work Action refs by real action ID or temp_* ref in a single batch call. When BAKER_CHAT_ID is set, a temp_* ref still staged in THIS chat resolves to status 'draft' (not 'not_found') \u2014 staged ops only become published actions on chat publish.",
+  args: {
+    ref: {
+      type: "positional",
+      description: "One or more action refs: real action IDs or temp_* refs (space-separated)",
+      required: true
+    }
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Resolve Work Action refs by real ID or temp_* ref. Example: baker actions status temp_hero jx123"
+  },
+  args: {
+    ref: { type: "positional", description: "Action ID or temp_* ref; accepts multiple refs", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const refs = [args.ref, ...Array.isArray(args._) ? args._ : []].filter((ref) => typeof ref === "string").map((ref) => ref.trim()).filter(Boolean);
+      if (refs.length === 0) {
+        failValidation("At least one action ref is required.");
+      }
+      const { BAKER_CHAT_ID } = getEnv();
+      const body = BAKER_CHAT_ID ? { refs, chatId: BAKER_CHAT_ID } : { refs };
+      const response = await apiPost("/api/actions/status", body);
+      writeJson(response);
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  statusCommand
+};
+//# sourceMappingURL=status-6X2YHFCG.js.map

package/dist/studies-2GPTKJCT.js

@@ -0,0 +1,250 @@
+import {
+  adStudyFromWire,
+  cellObjects,
+  unixSeconds
+} from "./chunk-GDFJOCDO.js";
+import {
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-B2POVFR2.js";
+import "./chunk-Y2JZX6JB.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-AGBBTTKA.js";
+import {
+  apiGet
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// ../api/src/ads-meta/adStudyDescription.ts
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function adStudyTime(seconds) {
+  const date = new Date(seconds * 1e3);
+  const hh = String(date.getUTCHours()).padStart(2, "0");
+  const mm = String(date.getUTCMinutes()).padStart(2, "0");
+  return `${date.getUTCDate()} ${MONTHS[date.getUTCMonth()]} ${date.getUTCFullYear()}, ${hh}:${mm} UTC`;
+}
+function daysLabel(seconds) {
+  const days = Math.round(seconds / 86400 * 10) / 10;
+  return `${days} ${days === 1 ? "day" : "days"}`;
+}
+function quoted(id, names) {
+  const name = names[id];
+  return name ? `"${name}"` : id;
+}
+function cellWords(cell, names) {
+  const [noun, ids] = cell.ads ? ["ad", cell.ads] : cell.adsets ? ["ad set", cell.adsets] : ["campaign", cell.campaigns ?? []];
+  const plural = ids.length > 1 ? `${noun}s` : noun;
+  const runs = ids.length > 0 ? ` (${plural} ${ids.map((id) => quoted(id, names)).join(", ")})` : "";
+  const share = cell.control_percentage === void 0 ? `${cell.treatment_percentage}%` : `${cell.treatment_percentage}% see the ads, ${cell.control_percentage}% held out`;
+  return `${cell.name}${runs} ${share}`;
+}
+var STUDY_KIND = {
+  SPLIT_TEST: "Split test",
+  LIFT: "Lift study",
+  SPLIT_TEST_V2: "Creative test"
+};
+function primaryObjective(objectives) {
+  if (!objectives || objectives.length === 0) {
+    return void 0;
+  }
+  return objectives.find((objective) => objective.is_primary === true) ?? objectives[0];
+}
+var SOURCE_NOUN = {
+  adspixels: "pixel",
+  applications: "app",
+  offsite_datasets: "dataset"
+};
+function sourceWords(objective, names) {
+  const words = [];
+  for (const key of ["adspixels", "applications", "offsite_datasets"]) {
+    for (const source of objective[key] ?? []) {
+      const events = source.event_names?.join(" or ") ?? "any event";
+      words.push(`${events} on ${SOURCE_NOUN[key]} ${quoted(source.id, names)}`);
+    }
+  }
+  for (const source of objective.customconversions ?? []) {
+    words.push(`custom conversion ${quoted(source.id, names)}`);
+  }
+  return words;
+}
+function measuringWords(objectives, names) {
+  const primary = primaryObjective(objectives);
+  if (!primary) {
+    return "cost per result on the campaigns' objective";
+  }
+  const sources = sourceWords(primary, names);
+  return `cost per "${primary.name}"${sources.length > 0 ? ` (${sources.join(", ")})` : ""}`;
+}
+function measuringPhrase(type, primary, measuring) {
+  if (type === "LIFT") return `measuring the lift in ${primary ? `"${primary.name}"` : "results"}`;
+  return `measuring ${primary ? `cost per "${primary.name}"` : measuring}`;
+}
+function describeAdStudy(study, { names = {} } = {}) {
+  const versions = study.cells && study.cells.length > 0 ? study.cells.map((cell) => cellWords(cell, names)).join(" vs ") : void 0;
+  const measuring = measuringWords(study.objectives, names);
+  const primary = primaryObjective(study.objectives);
+  const others = (study.objectives ?? []).filter((objective) => objective !== primary);
+  const alsoMeasured = others.length > 0 ? others.map((objective) => `"${objective.name}"`).join(", ") : void 0;
+  const hasSchedule = study.start_time !== void 0 && study.end_time !== void 0;
+  const length = hasSchedule ? daysLabel((study.end_time ?? 0) - (study.start_time ?? 0)) : void 0;
+  const schedule = hasSchedule ? `${adStudyTime(study.start_time ?? 0)} \u2192 ${adStudyTime(study.end_time ?? 0)} \xB7 ${length}` : void 0;
+  const confidence = study.confidence_level !== void 0 ? `${Math.round(study.confidence_level * 100)}%` : void 0;
+  const parts = [
+    versions,
+    measuringPhrase(study.type, primary, measuring),
+    length,
+    confidence ? `${confidence} confidence` : void 0
+  ].filter((part) => part !== void 0);
+  const kind = STUDY_KIND[study.type ?? "SPLIT_TEST"] ?? "Split test";
+  return { sentence: `${kind}: ${parts.join(", ")}`, versions, measuring, alsoMeasured, schedule, confidence };
+}
+
+// src/commands/ads/meta/studies.ts
+import { defineCommand } from "citty";
+function studyState(row, nowSeconds) {
+  if (row.canceled_time) return "cancelled";
+  const start = unixSeconds(row.start_time) ?? 0;
+  const end = unixSeconds(row.end_time) ?? Number.POSITIVE_INFINITY;
+  if (nowSeconds < start) return "scheduled";
+  return nowSeconds < end ? "running" : "ended";
+}
+function compactStudy(row, nowSeconds) {
+  const study = adStudyFromWire(row);
+  const words = describeAdStudy(study, { names: study.names });
+  return {
+    id: study.id,
+    name: study.name,
+    state: studyState(row, nowSeconds),
+    compares: words.versions,
+    ...study.start_time !== void 0 ? { starts: adStudyTime(study.start_time) } : {},
+    ...study.end_time !== void 0 ? { ends: adStudyTime(study.end_time) } : {},
+    ...row.results_first_available_date ? { results_from: row.results_first_available_date } : {}
+  };
+}
+function studyDetail(row, nowSeconds) {
+  const study = adStudyFromWire(row);
+  const measures = (row.objectives?.data ?? []).map((objective) => ({
+    id: objective.id,
+    name: objective.name,
+    primary: objective.is_primary === true,
+    ...objective.results !== void 0 ? { results: objective.results } : {}
+  }));
+  return {
+    ...compactStudy(row, nowSeconds),
+    ...study.description ? { description: study.description } : {},
+    versions: study.cells.map((cell) => ({
+      cell_id: cell.id,
+      name: cell.name,
+      share: `${cell.treatment_percentage}%`,
+      runs: cellObjects(cell).map((id) => ({ id, name: study.names[id] })),
+      level: cell.ads ? "ad" : cell.adsets ? "ad set" : "campaign"
+    })),
+    measures
+  };
+}
+function studyHints(detail) {
+  const state = detail.state;
+  if (state === "scheduled") {
+    return [
+      "Not started: it can still be re-timed, re-split (`studies update --split <cell_id>=60 \u2026`) or deleted. Results appear once it runs."
+    ];
+  }
+  const measures = detail.measures ?? [];
+  const hasResults = measures.some((measure) => measure.results !== void 0);
+  return [
+    hasResults ? "Meta's verdict is in each measure's results, with its confidence. Report a winner only when Meta names one at the test's confidence level; otherwise say the versions performed alike." : "No results yet \u2014 Meta publishes them once the test has gathered enough. Compare per-version delivery meanwhile with `baker ads meta insights --object <ad set or campaign id>`, and do not call a winner from it.",
+    state === "running" ? "Running: its split and start are fixed; it can be renamed, its end moved, ended now (`studies end`) or deleted (results and all)." : "Over. Read the per-version numbers with `baker ads meta insights --object <id>` for the period it ran."
+  ];
+}
+registerSchema({
+  command: "ads.meta.studies",
+  description: "Meta A/B tests (ad studies) whose versions run in an ad account \u2014 what each compares, when it runs and its state (scheduled, running, ended). --study-id reads one: every version with its cell id and share, and each measure with Meta's results. --business-id lists every test on a Business. Stage new ones with `studies create`.",
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)", required: false },
+    "business-id": { type: "string", description: "List every test on this Business instead", required: false },
+    "study-id": { type: "string", description: "One test: its versions and results", required: false },
+    full: { type: "boolean", description: "The tests as Meta returns them", required: false },
+    "no-cache": { type: "boolean", description: "Bypass the cache", required: false }
+  }
+});
+var listArgs = {
+  "account-id": { type: "string", description: "Meta ad account ID" },
+  "business-id": { type: "string", description: "List every test on this Business instead" },
+  "study-id": { type: "string", description: "Read one test: versions, cell ids, results" },
+  full: { type: "boolean", description: "The tests as Meta returns them" },
+  "no-cache": NO_CACHE_ARG
+};
+async function read(path, params, noCache) {
+  if (noCache) params["skip-cache"] = "true";
+  return await apiGet(path, params);
+}
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List A/B tests. Runs by default. Example: baker ads meta studies --account-id act_123 \xB7 one test: baker ads meta studies --study-id 6123"
+  },
+  args: listArgs,
+  run: async ({ args }) => {
+    const now = Math.floor(Date.now() / 1e3);
+    try {
+      if (args["study-id"]) {
+        const row = await read(
+          "/api/ads/meta/study-results",
+          { "study-id": String(args["study-id"]) },
+          args["no-cache"]
+        );
+        const detail = studyDetail(row, now);
+        writeJsonEnvelope({ ok: true, data: args.full ? row : detail, hints: studyHints(detail) });
+        return;
+      }
+      const params = args["business-id"] ? { "business-id": String(args["business-id"]) } : { "account-id": resolveAccountIdArg(args) };
+      const rows = await read("/api/ads/meta/studies", params, args["no-cache"]);
+      const hints = rows.length === 0 ? [
+        "No A/B tests. To set one up: duplicate the ad set (`adsets duplicate`), change ONE thing on the copy, then `studies create --adsets <original>,<copy>`."
+      ] : ["`studies --study-id <id>` reads one test's versions and results."];
+      writeJsonEnvelope({ ok: true, data: args.full ? rows : rows.map((row) => compactStudy(row, now)), hints });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+var studiesCommand = defineCommand({
+  meta: {
+    name: "studies",
+    description: `Meta A/B tests (ad studies): Meta splits one audience between versions \u2014 ad sets or campaigns \u2014 so each person sees one, and calls the winner.
+Not Baker's own page experiments (\`baker experiment\`), which test landing pages.
+
+Examples:
+  baker ads meta studies --account-id act_123                    # tests on this account and their state
+  baker ads meta studies --study-id 6123                          # versions, cell ids, Meta's results
+  baker ads meta studies create --name "Broad vs lookalike" --adsets 6123,6124 --start 2026-10-20T08:00Z --days 14 --confidence 90
+  baker ads meta studies update 6123 --end 2026-11-10T08:00Z
+  baker ads meta studies end 6123 | delete 6123`
+  },
+  subCommands: {
+    list: listCommand,
+    create: () => import("./study-writes-QCSAPE2G.js").then((m) => m.studiesCreateCommand),
+    update: () => import("./study-writes-QCSAPE2G.js").then((m) => m.studiesUpdateCommand),
+    end: () => import("./study-writes-QCSAPE2G.js").then((m) => m.studiesEndCommand),
+    delete: () => import("./study-writes-QCSAPE2G.js").then((m) => m.studiesDeleteCommand)
+  },
+  args: listArgs,
+  default: "list"
+});
+export {
+  compactStudy,
+  studiesCommand,
+  studyDetail,
+  studyHints,
+  studyState
+};
+//# sourceMappingURL=studies-2GPTKJCT.js.map

package/dist/studio-WMVZXCGB.js

@@ -0,0 +1,49 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/studio/index.ts
+import { defineCommand } from "citty";
+var studioCommand = defineCommand({
+  meta: {
+    name: "studio",
+    description: `Make new imagery and clips. Every batch is recorded and shows up in the dashboard Studio for the client to review, labelled with this conversation.
+
+Make something:
+  baker studio generate <prompt> [--reference ids,paths,urls] [--model \u2026] [--aspect-ratio \u2026] [--count N]
+                                        Render 1-8 takes of one still; each is ingested into the media library as it lands
+  baker studio animate <prompt> --image <id|path|url,\u2026>
+                                        Turn a still into a clip \u2014 the prompt describes MOVEMENT, not the look
+  baker studio skills                   Craft directions you can pass to --skill
+  baker studio improve <prompt>         Sharpen a rough brief (use it for the CLIENT's words, not your own)
+
+Know what you can ask for:
+  baker studio models [--kind video] [--model <id>]
+                                        Per model: shapes, resolutions, clip lengths, prompt cap, reference limit, every knob
+
+Review and pick:
+  baker studio get <generationId>       One batch: every take, its url, whether it is in the library, why one failed
+  baker studio list [--kind image|video] [--all]
+                                        Recent batches for this conversation (--all = the whole company)
+  baker studio keep <generationId> --slot N
+                                        Mark the keeper. Stars an image; INGESTS a clip into the video library
+
+Three rules worth remembering:
+  - --reference is the biggest quality lever there is. Ground a render in a real logo, product shot or mood image.
+  - A clip is not usable anywhere until it is kept. Unkept takes are never ingested.
+  - The models disagree about what they accept, and a setting the chosen model does not have is REFUSED rather than ignored. Run baker studio models to answer "can this one do that".
+Full guide: __tooling__/docs/tools/baker/studio.md`
+  },
+  subCommands: {
+    generate: () => import("./generate-K6VXX5FY.js").then((m) => m.generateCommand),
+    animate: () => import("./animate-5VPSJCK7.js").then((m) => m.animateCommand),
+    get: () => import("./get-WJYHHRTS.js").then((m) => m.getCommand),
+    list: () => import("./list-3M6LPVUB.js").then((m) => m.listCommand),
+    keep: () => import("./keep-44JRYTBY.js").then((m) => m.keepCommand),
+    models: () => import("./models-YT6I2T5Z.js").then((m) => m.modelsCommand),
+    skills: () => import("./skills-P6CA3YSS.js").then((m) => m.skillsCommand),
+    improve: () => import("./improve-S47VKH5Y.js").then((m) => m.improveCommand)
+  }
+});
+export {
+  studioCommand
+};
+//# sourceMappingURL=studio-WMVZXCGB.js.map