@koda-sl/baker-cli 0.481.0-dev.2d33e194f → 0.482.0-dev.a5555ab55

package/dist/check-545MAB4E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/creatives/check.ts"],"sourcesContent":["/**\n * `baker creatives check`: the ads already made, read against the company's rules as they stand\n * now. After a rule is added it says which existing ads break it, deterministically (the words\n * a rule bans or requires), so nothing is marked stale and nothing re-renders: the person decides\n * which to correct.\n */\nimport { readdir, readFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { defineCommand } from \"citty\";\nimport { ruleTells } from \"../../engine/copy-tells/rule-tells.ts\";\nimport { type AdWords, readAdWords } from \"../../engine/creative-context/ad-words.ts\";\nimport { readAllRules } from \"../../engine/creative-context/index.ts\";\nimport type { CreativeRule } from \"../../engine/creative-rules/schema.ts\";\nimport { selectRules } from \"../../engine/creative-rules/select.ts\";\nimport { writeJson } from \"../../output.ts\";\nimport { registerSchema } from \"../../schemas.ts\";\nimport { marketFromCompanyDoc } from \"../../viewer-profile.ts\";\nimport { findWorkspaceRoot } from \"../canvas/normalize-paths.ts\";\nimport { ruleRefusal } from \"../canvas/rule-gate.ts\";\n\nconst DESCRIPTION = `Read every creative already made against the company's rules as they stand now: which ads say words a rule bans, or leave out words a rule requires. Run it after adding a rule (\\`baker creatives rules add\\`); nothing is re-rendered or marked stale, so ask the person which ads to correct.\nStart here: baker creatives check\n  baker creatives check --slug mba-ia-online   # one creative`;\n\nconst ARGS = {\n  slug: { type: \"string\", description: \"One creative (src/creatives/<slug>/); left out, every one\", required: false },\n} as const;\n\nregisterSchema({ command: \"creatives.check\", description: DESCRIPTION, args: ARGS });\n\nexport type CheckReport = { checked: number; breaking: Array<{ creative: string; broken: string[] }> };\n\n/** Each ad that breaks a rule holding for it, with what it breaks. Pure. */\nexport function checkCreatives(\n  ads: ReadonlyArray<{ slug: string; ad: AdWords }>,\n  rules: readonly CreativeRule[],\n  companyLanguage: string | undefined,\n): CheckReport {\n  const breaking = ads.flatMap(({ slug, ad }) => {\n    const held = selectRules(\n      rules,\n      {\n        kind: ad.kind,\n        ...(ad.product ? { product: ad.product } : {}),\n        ...(ad.platform ? { platform: ad.platform } : {}),\n        ...(ad.platforms ? { platforms: ad.platforms } : {}),\n      },\n      ad.waived,\n    );\n    const refusal = ruleRefusal(ruleTells(ad.lines, held, ad.language ?? companyLanguage));\n    return refusal ? [{ creative: slug, broken: refusal.problems }] : [];\n  });\n  return { checked: ads.length, breaking };\n}\n\n/** Every creative folder's words, or the one named. */\nasync function readAds(root: string, slug?: string): Promise<Array<{ slug: string; ad: AdWords }>> {\n  const dir = path.join(root, \"src\", \"creatives\");\n  const slugs = slug\n    ? [slug]\n    : (await readdir(dir, { withFileTypes: true }).catch(() => []))\n        .filter((e) => e.isDirectory() && !e.name.startsWith(\"_\"))\n        .map((e) => e.name)\n        .sort();\n  const ads = await Promise.all(slugs.map(async (s) => ({ slug: s, ad: await readAdWords(path.join(dir, s)) })));\n  return ads.flatMap(({ slug: s, ad }) => (ad ? [{ slug: s, ad }] : []));\n}\n\nexport const checkCommand = defineCommand({\n  meta: { name: \"check\", description: DESCRIPTION },\n  args: ARGS,\n  async run({ args }) {\n    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();\n    const slug = typeof args.slug === \"string\" && args.slug ? args.slug : undefined;\n    const [ads, rules, companyDoc] = await Promise.all([\n      readAds(root, slug),\n      readAllRules(root),\n      readFile(path.join(root, \"COMPANY.md\"), \"utf8\").catch(() => null),\n    ]);\n    const report = checkCreatives(ads, rules, marketFromCompanyDoc(companyDoc)?.language);\n    writeJson({\n      ok: true,\n      data: report,\n      hints:\n        report.breaking.length > 0\n          ? [\n              `${report.breaking.length} of ${report.checked} ads break a rule now in force. Tell the person which, and correct only the ones they want: edit the words in that ad's prompt.json and run it again, or waive the rule there if the person asked for those words.`,\n            ]\n          : [`None of the ${report.checked} ads breaks a wording rule now in force.`],\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,SAAS,gBAAgB;AAClC,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAY9B,IAAM,cAAc;AAAA;AAAA;AAIpB,IAAM,OAAO;AAAA,EACX,MAAM,EAAE,MAAM,UAAU,aAAa,6DAA6D,UAAU,MAAM;AACpH;AAEA,eAAe,EAAE,SAAS,mBAAmB,aAAa,aAAa,MAAM,KAAK,CAAC;AAK5E,SAAS,eACd,KACA,OACA,iBACa;AACb,QAAM,WAAW,IAAI,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;AAC7C,UAAM,OAAO;AAAA,MACX;AAAA,MACA;AAAA,QACE,MAAM,GAAG;AAAA,QACT,GAAI,GAAG,UAAU,EAAE,SAAS,GAAG,QAAQ,IAAI,CAAC;AAAA,QAC5C,GAAI,GAAG,WAAW,EAAE,UAAU,GAAG,SAAS,IAAI,CAAC;AAAA,QAC/C,GAAI,GAAG,YAAY,EAAE,WAAW,GAAG,UAAU,IAAI,CAAC;AAAA,MACpD;AAAA,MACA,GAAG;AAAA,IACL;AACA,UAAM,UAAU,YAAY,UAAU,GAAG,OAAO,MAAM,GAAG,YAAY,eAAe,CAAC;AACrF,WAAO,UAAU,CAAC,EAAE,UAAU,MAAM,QAAQ,QAAQ,SAAS,CAAC,IAAI,CAAC;AAAA,EACrE,CAAC;AACD,SAAO,EAAE,SAAS,IAAI,QAAQ,SAAS;AACzC;AAGA,eAAe,QAAQ,MAAc,MAA8D;AACjG,QAAM,MAAM,KAAK,KAAK,MAAM,OAAO,WAAW;AAC9C,QAAM,QAAQ,OACV,CAAC,IAAI,KACJ,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC,CAAC,GACxD,OAAO,CAAC,MAAM,EAAE,YAAY,KAAK,CAAC,EAAE,KAAK,WAAW,GAAG,CAAC,EACxD,IAAI,CAAC,MAAM,EAAE,IAAI,EACjB,KAAK;AACZ,QAAM,MAAM,MAAM,QAAQ,IAAI,MAAM,IAAI,OAAO,OAAO,EAAE,MAAM,GAAG,IAAI,MAAM,YAAY,KAAK,KAAK,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;AAC7G,SAAO,IAAI,QAAQ,CAAC,EAAE,MAAM,GAAG,GAAG,MAAO,KAAK,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,CAAE;AACvE;AAEO,IAAM,eAAe,cAAc;AAAA,EACxC,MAAM,EAAE,MAAM,SAAS,aAAa,YAAY;AAAA,EAChD,MAAM;AAAA,EACN,MAAM,IAAI,EAAE,KAAK,GAAG;AAClB,UAAM,OAAO,kBAAkB,QAAQ,IAAI,CAAC,KAAK,QAAQ,IAAI;AAC7D,UAAM,OAAO,OAAO,KAAK,SAAS,YAAY,KAAK,OAAO,KAAK,OAAO;AACtE,UAAM,CAAC,KAAK,OAAO,UAAU,IAAI,MAAM,QAAQ,IAAI;AAAA,MACjD,QAAQ,MAAM,IAAI;AAAA,MAClB,aAAa,IAAI;AAAA,MACjB,SAAS,KAAK,KAAK,MAAM,YAAY,GAAG,MAAM,EAAE,MAAM,MAAM,IAAI;AAAA,IAClE,CAAC;AACD,UAAM,SAAS,eAAe,KAAK,OAAO,qBAAqB,UAAU,GAAG,QAAQ;AACpF,cAAU;AAAA,MACR,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,OACE,OAAO,SAAS,SAAS,IACrB;AAAA,QACE,GAAG,OAAO,SAAS,MAAM,OAAO,OAAO,OAAO;AAAA,MAChD,IACA,CAAC,eAAe,OAAO,OAAO,0CAA0C;AAAA,IAChF,CAAC;AAAA,EACH;AACF,CAAC;","names":[]}

package/dist/chunk-232YUPUI.js

@@ -0,0 +1,125 @@
+import {
+  apiGet
+} from "./chunk-XDZVBX6L.js";
+
+// src/commands/studio/batch.ts
+function projectBatch(generation, full) {
+  const compact = {
+    generationId: generation.generationId,
+    kind: generation.kind,
+    status: generation.status,
+    prompt: generation.prompt,
+    model: generation.model,
+    aspectRatio: generation.aspectRatio,
+    variants: generation.variants.map((variant) => ({
+      slot: variant.slot,
+      status: variant.status,
+      ...variant.imageId ? { imageId: variant.imageId } : {},
+      ...variant.videoId ? { videoId: variant.videoId } : {},
+      ...variant.url ? { url: variant.url } : {},
+      inLibrary: variant.inLibrary,
+      ...variant.error ? { error: variant.error } : {}
+    }))
+  };
+  if (!full) return compact;
+  return {
+    ...compact,
+    ...generation.skillId ? { skillId: generation.skillId } : {},
+    ...generation.imageSettings ? { imageSettings: generation.imageSettings } : {},
+    ...generation.clipSettings ? { clipSettings: generation.clipSettings } : {},
+    ...generation.referenceImageIds ? { referenceImageIds: generation.referenceImageIds } : {},
+    ...generation.chatId ? { chatId: generation.chatId } : {},
+    createdAt: generation.createdAt
+  };
+}
+function slotArg(candidates) {
+  return candidates.length === 1 ? `--slot ${candidates[0]?.slot}` : "--slot <n>";
+}
+function chooseFirst(candidates) {
+  return candidates.length === 1 ? "" : " Look at the takes and pick one \u2014 do not default to the first.";
+}
+function batchHints(generation) {
+  const id = generation.generationId;
+  if (generation.status === "running") {
+    return [
+      `Still rendering. Run \`baker studio get ${id}\` when you need the result \u2014 do not start the same batch again.`
+    ];
+  }
+  const hints = [];
+  const ready = generation.variants.filter((variant) => variant.status === "ready");
+  const failed = generation.variants.filter((variant) => variant.status === "failed");
+  if (generation.kind === "image" && ready.length > 0) {
+    hints.push(
+      'Every rendered image is already in the media library and searchable \u2014 `baker images library "<what it shows>"` finds it, and you can use its image id straight away.'
+    );
+    hints.push(
+      `Mark the take you are using: \`baker studio keep ${id} ${slotArg(ready)}\` stars it so the client reviews the right one.${chooseFirst(ready)}`
+    );
+  }
+  const unkeptClips = ready.filter((variant) => !variant.inLibrary);
+  if (generation.kind === "video" && unkeptClips.length > 0) {
+    hints.push(
+      `A clip is not usable anywhere \u2014 canvas, landing, ad \u2014 until you keep it. \`baker studio keep ${id} ${slotArg(unkeptClips)}\` puts it in the video library; takes nobody keeps are never ingested.${chooseFirst(unkeptClips)}`
+    );
+  }
+  if (generation.status === "partial" && failed.length > 0) {
+    hints.push(
+      `${failed.length === 1 ? "This take" : "These takes"} did not render \u2014 ${failed.map((variant) => `take ${variant.slot}: ${variant.error ?? "no reason given"}`).join("; ")}. Use the ones that did and carry on; do not re-run the whole batch.`
+    );
+  }
+  if (generation.status === "failed") {
+    hints.push(
+      `No take rendered \u2014 ${failed[0]?.error ?? "no reason given"}. Continue the job with a sourced or existing asset rather than stopping.`
+    );
+  }
+  return hints;
+}
+function waitingHint(outcome, generationId, maxWaitMs) {
+  const collect = `Run \`baker studio get ${generationId}\` to pick it up \u2014 the batch is still going, so do not start it again.`;
+  if (outcome.kind === "unreachable") {
+    return `The batch started and is rendering, but reading it back failed (${outcome.reason}). ${collect}`;
+  }
+  return `Still rendering after ${Math.round(maxWaitMs / 1e3)}s. ${collect}`;
+}
+var FALSEY_FLAG_VALUES = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
+function resolveMaxWaitMs(wait, maxWait, defaultMs) {
+  if (typeof wait === "string" && FALSEY_FLAG_VALUES.has(wait.trim().toLowerCase())) return 0;
+  if (wait === false) return 0;
+  if (maxWait === void 0 || maxWait === "") return defaultMs;
+  const parsed = Number(maxWait);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : defaultMs;
+}
+var POLL_INTERVAL_MS = 3e3;
+var defaultPollDeps = {
+  get: async (generationId) => {
+    const response = await apiGet(`/api/studio/generations/${generationId}`);
+    return response.generation;
+  },
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+};
+async function pollBatch(generationId, maxWaitMs, deps = defaultPollDeps) {
+  const deadline = Date.now() + maxWaitMs;
+  while (Date.now() < deadline) {
+    const generation = await deps.get(generationId);
+    if (generation.status !== "running") return generation;
+    await deps.sleep(POLL_INTERVAL_MS);
+  }
+  return null;
+}
+async function awaitBatch(generationId, maxWaitMs, deps = defaultPollDeps) {
+  try {
+    const generation = await pollBatch(generationId, maxWaitMs, deps);
+    return generation ? { kind: "settled", generation } : { kind: "still-running" };
+  } catch (error) {
+    return { kind: "unreachable", reason: error instanceof Error ? error.message : "the read failed" };
+  }
+}
+
+export {
+  projectBatch,
+  batchHints,
+  waitingHint,
+  resolveMaxWaitMs,
+  awaitBatch
+};
+//# sourceMappingURL=chunk-232YUPUI.js.map

package/dist/chunk-23H4ZJRP.js

@@ -0,0 +1,136 @@
+import {
+  coercePathUrlToUrl,
+  looksLikeHttpUrl
+} from "./chunk-2FSEESJU.js";
+
+// src/commands/canvas/resolve-paths.ts
+import path from "path";
+function resolveRelativeCanvasPaths(canvas, baseDir) {
+  if (!canvas || typeof canvas !== "object") return canvas;
+  const c = canvas;
+  if (!Array.isArray(c.nodes)) return canvas;
+  return { ...canvas, nodes: c.nodes.map((n) => resolveNode(n, baseDir)) };
+}
+function localPathParam(node) {
+  if (node.type === "ingest") return node.params?.source === "path" ? "path" : null;
+  if (node.type === "hyperframe_render" || node.type === "hyperframe_snapshot") return "composition";
+  return null;
+}
+function resolveNode(node, baseDir) {
+  if (!node || typeof node !== "object") return node;
+  const n = node;
+  const params = n.params;
+  if (!params || typeof params !== "object") return node;
+  const key = localPathParam(n);
+  if (key && isResolvableRelative(params[key])) {
+    return { ...node, params: { ...params, [key]: path.resolve(baseDir, params[key]) } };
+  }
+  return node;
+}
+function isResolvableRelative(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path.isAbsolute(value);
+}
+
+// src/commands/canvas/normalize-paths.ts
+import { existsSync, realpathSync } from "fs";
+import { writeFile } from "fs/promises";
+import path2 from "path";
+function findWorkspaceRoot(startDir, exists = existsSync, maxDepth = 12) {
+  let dir = path2.resolve(startDir);
+  for (let i = 0; i < maxDepth; i++) {
+    if (exists(path2.join(dir, "package.json"))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function canvasOutputsRoot(canvasFile, cwd = process.cwd(), exists = existsSync) {
+  const root = findWorkspaceRoot(path2.dirname(path2.resolve(cwd, canvasFile)), exists) ?? cwd;
+  return path2.join(root, "canvas");
+}
+function canonicalize(target) {
+  const abs = path2.resolve(target);
+  let dir = abs;
+  for (; ; ) {
+    try {
+      const real = realpathSync(dir);
+      return dir === abs ? real : path2.join(real, path2.relative(dir, abs));
+    } catch {
+      const parent = path2.dirname(dir);
+      if (parent === dir) return abs;
+      dir = parent;
+    }
+  }
+}
+function isInside(root, target) {
+  const rel = path2.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+}
+function toCanvasRelative(canvasDir, target) {
+  return path2.relative(canvasDir, target).split(path2.sep).join("/");
+}
+var RUNTIME_WORKSPACE_ROOT = "/home/user/repo";
+function rewriteTarget(value, workspaceRoot) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  if (value.includes("[TODO") || looksLikeHttpUrl(value) || !path2.isAbsolute(value)) return null;
+  const target = canonicalize(value);
+  if (isInside(workspaceRoot, target)) return target;
+  const fromRuntime = path2.relative(RUNTIME_WORKSPACE_ROOT, path2.normalize(value));
+  if (fromRuntime !== "" && !fromRuntime.startsWith("..") && !path2.isAbsolute(fromRuntime)) {
+    return path2.join(workspaceRoot, fromRuntime);
+  }
+  return null;
+}
+function normalizeCanvasPaths(canvas, canvasDir, workspaceRoot) {
+  if (!canvas || typeof canvas !== "object") return { canvas, rewrites: [] };
+  const c = canvas;
+  if (!Array.isArray(c.nodes)) return { canvas, rewrites: [] };
+  const root = canonicalize(workspaceRoot);
+  const dir = canonicalize(canvasDir);
+  const rewrites = [];
+  const nodes = c.nodes.map((node) => {
+    if (!node || typeof node !== "object") return node;
+    const n = node;
+    const params = n.params;
+    if (!params || typeof params !== "object") return node;
+    const nodeId = typeof n.id === "string" ? n.id : "?";
+    if (n.type === "ingest" && params.source === "path" && looksLikeHttpUrl(params.path)) {
+      rewrites.push({ nodeId, param: "source", from: "path", to: "url" });
+      return { ...node, params: coercePathUrlToUrl(params) };
+    }
+    const key = localPathParam(n);
+    if (!key) return node;
+    const target = rewriteTarget(params[key], root);
+    if (target === null) return node;
+    const to = toCanvasRelative(dir, target);
+    rewrites.push({ nodeId, param: key, from: params[key], to });
+    return { ...node, params: { ...params, [key]: to } };
+  });
+  return rewrites.length === 0 ? { canvas, rewrites } : { canvas: { ...canvas, nodes }, rewrites };
+}
+async function healCanvasPaths(filePath, canvas) {
+  const canvasDir = path2.dirname(filePath);
+  const workspaceRoot = findWorkspaceRoot(canvasDir);
+  if (!workspaceRoot) return { canvas, rewrites: [], text: null };
+  const normalized = normalizeCanvasPaths(canvas, canvasDir, workspaceRoot);
+  if (normalized.rewrites.length === 0) return { ...normalized, text: null };
+  const text = `${JSON.stringify(normalized.canvas, null, 2)}
+`;
+  await writeFile(filePath, text, "utf8");
+  return { ...normalized, text };
+}
+function describeRewrites(rewrites) {
+  return rewrites.map((r) => `  ${r.nodeId}.${r.param}: ${r.from} \u2192 ${r.to}`).join("\n");
+}
+
+export {
+  resolveRelativeCanvasPaths,
+  localPathParam,
+  findWorkspaceRoot,
+  canvasOutputsRoot,
+  normalizeCanvasPaths,
+  healCanvasPaths,
+  describeRewrites
+};
+//# sourceMappingURL=chunk-23H4ZJRP.js.map