@koda-sl/baker-cli 0.561.0 → 0.563.0-dev.25ca3cbc8

package/dist/chunk-KFCN6DEX.js

@@ -0,0 +1,89 @@
+import {
+  readAvatars
+} from "./chunk-OFMFBRSL.js";
+import {
+  readCompanyReading
+} from "./chunk-TFF2G2WU.js";
+import {
+  apiPost
+} from "./chunk-QEREDRZO.js";
+
+// src/commands/creatives/cast-inventory.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+var short = (text, max) => text.length > max ? `${text.slice(0, max - 1).trimEnd()}\u2026` : text;
+var nameKey = (name) => name.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase().replace(/\b(?:inc|llc|ltd|gmbh|sl|sa|corp|co)\b\.?/g, "").replace(/[^\p{L}\p{N}]/gu, "");
+function isTheCompany(employer, company) {
+  const key = nameKey(employer);
+  if (key.length < 3) return false;
+  return [company.name ?? "", ...company.brands ?? []].some((own) => {
+    const ownKey = nameKey(own);
+    return ownKey.length >= 3 && (key.includes(ownKey) || ownKey.includes(key));
+  });
+}
+function avatarRelation(avatar, company) {
+  if (avatar.relation) return avatar.relation;
+  if (avatar.likeness === "synthetic" && !avatar.person) return "role";
+  return avatar.person?.company && isTheCompany(avatar.person.company, company) ? "team" : "unknown";
+}
+var CASTABLE = ["team", "founder", "role"];
+function avatarsOf(response, company = {}) {
+  return response.avatars.filter((a) => a.status === "ready").map((a) => {
+    const real = a.likeness === "licensed" || Boolean(a.person);
+    const role = [a.person?.role, a.person?.company].filter(Boolean).join(" at ");
+    const relation = avatarRelation(a, company);
+    return {
+      handle: a.handle,
+      real,
+      who: short(role || a.subjectDescription || a.name, 90),
+      relation,
+      castable: CASTABLE.includes(relation),
+      ...a.testimonialIds?.length ? { testimonialIds: a.testimonialIds } : {}
+    };
+  });
+}
+async function companyName(root) {
+  const doc = await readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => "");
+  const title = /^#\s+(.+?)\s*$/m.exec(doc)?.[1] ?? "";
+  return title.replace(/[*_`]/g, "").replace(/^(?:company|empresa|compañía)\s*:\s*/i, "") || void 0;
+}
+async function castCompany(root) {
+  const [name, reading] = await Promise.all([companyName(root), readCompanyReading(root).catch(() => null)]);
+  return { ...name ? { name } : {}, brands: reading?.brands ?? [] };
+}
+function customersOf(found) {
+  return found.filter((t) => t.sentiment !== "negative" && (t.highlight || t.reviewText).trim()).slice(0, 3).map((t) => ({
+    ...t.reviewerName ? { name: t.reviewerName } : {},
+    words: short((t.highlight || t.reviewText).trim().replace(/\s+/g, " "), 140),
+    source: t.sourceType,
+    photo: Boolean(t.reviewerImageUrl || t.reviewerImageId || t.imageIds?.length || t.videoIds?.length)
+  }));
+}
+var LOGO_FILE = /\.(svg|png|webp|jpe?g)$/i;
+async function castInventory(root, message, company) {
+  const own = await castCompany(root);
+  const [avatars, customers, logos] = await Promise.all([
+    readAvatars("/api/avatars", { status: "ready" }).then(
+      (response) => avatarsOf(response, { ...own, ...company ? { name: company } : {} }),
+      () => []
+    ),
+    apiPost("/api/testimonials/search", { query: message, limit: 6 }).then(
+      customersOf,
+      () => []
+    ),
+    readdir(path.join(root, "src", "brand", "logos")).then(
+      (files) => files.filter((f) => LOGO_FILE.test(f)).map((f) => `src/brand/logos/${f}`),
+      () => []
+    )
+  ]);
+  return { avatars, customers, logos, ...company ? { company } : {} };
+}
+
+export {
+  avatarRelation,
+  avatarsOf,
+  companyName,
+  castCompany,
+  castInventory
+};
+//# sourceMappingURL=chunk-KFCN6DEX.js.map

package/dist/chunk-KHVZZTWD.js

@@ -0,0 +1,46 @@
+import {
+  RENDER_REVIEW_MODEL,
+  askAboutImages,
+  buildRulesReviewPrompt,
+  classifyRuleFindings,
+  reviewedRules,
+  rulesSystem
+} from "./chunk-IZMSISEN.js";
+
+// src/engine/nodes/local/lib/confirm-blocking.ts
+var cutByFrame = (f) => f.kind?.defect === "cut";
+async function confirmBlocking(findings, stills, formats, ask) {
+  const claims = findings.filter((f) => f.severity === "blocking" && !cutByFrame(f));
+  if (claims.length === 0 || stills.length === 0) return [...findings];
+  const prompt = [
+    `These are the finished sizes of one ad, in order: ${formats.map((f, i) => `Image ${i + 1} is the ${f}`).join("; ")}.`,
+    "A reviewer reported each claim below. Look again at the size each one names (and, for a claim comparing sizes, at the others) and answer true only when the defect is plainly there for someone looking at it on a phone.",
+    "Answer false when the thing is not there, when it is an ordinary part of the scene (a second house, a neighbour's roof, a reflection), or when the sizes it compares show the same thing.",
+    ...claims.map((c, i) => `${i + 1}. ${c.what}`),
+    `Reply with only this JSON: {"answers":[true|false, ...]}, one answer per claim, in order.`
+  ].join("\n");
+  const answer = await ask([...stills], prompt).catch(() => null);
+  const answers = answer?.answers;
+  if (!Array.isArray(answers) || answers.length !== claims.length) return [...findings];
+  const unconfirmed = new Set(claims.filter((_, i) => answers[i] === false));
+  return findings.map((f) => unconfirmed.has(f) ? { ...f, severity: "warning" } : f);
+}
+
+// src/engine/nodes/local/lib/rules-review.ts
+var RULES_REVIEW_TIMEOUT_MS = 12e4;
+async function reviewAgainstRules(opts) {
+  const rules = reviewedRules(opts.rules);
+  if (rules.length === 0 || opts.stills.length === 0) return [];
+  const system = rulesSystem(rules);
+  const ask = (images, prompt) => askAboutImages(RENDER_REVIEW_MODEL, images, prompt, opts.onSpend, RULES_REVIEW_TIMEOUT_MS, void 0, system);
+  const answer = await ask([...opts.stills], buildRulesReviewPrompt({ formats: opts.formats, rules }));
+  if (answer === null) return null;
+  return await confirmBlocking(classifyRuleFindings(answer, rules), opts.stills, opts.formats, ask);
+}
+
+export {
+  cutByFrame,
+  confirmBlocking,
+  reviewAgainstRules
+};
+//# sourceMappingURL=chunk-KHVZZTWD.js.map

package/dist/chunk-L3ITBLLD.js

@@ -0,0 +1,197 @@
+import {
+  mediaTagsCreateRequestSchema,
+  mediaTagsDeleteRequestSchema,
+  mediaTagsUpdateRequestSchema
+} from "./chunk-OVNVYNVH.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+
+// src/lib/tags-command.ts
+import { defineCommand } from "citty";
+var OUTPUT_ARG = {
+  output: { type: "string", description: "Output format: md|json", required: false, default: "md" }
+};
+var SHARED_POOL_HINT = "Custom tags are one pool shared by images, videos and testimonials \u2014 this change shows up in all three. Already applied: publishing or discarding this chat does not undo it.";
+function fail(err) {
+  const code = err instanceof ApiError ? err.code : "INTERNAL_ERROR";
+  const message = err instanceof ApiError ? err.message : "Unexpected error";
+  writeJson({ ok: false, error: { code, message } });
+  process.exit(1);
+}
+function failInvalid(issue) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: issue?.message ?? "Invalid request" } });
+  process.exit(1);
+}
+function makeTagsCommand(command, label, endpoint) {
+  registerSchema({
+    command: `${command}.tags.list`,
+    description: `List the available ${label} tag taxonomy (built-in defaults + this company's custom tags).`,
+    args: OUTPUT_ARG
+  });
+  const listCommand = defineCommand({
+    meta: {
+      name: "list",
+      description: `List the available ${label} tag names (defaults + company custom tags). Use before filtering with --tags. Example: baker ${command} tags`
+    },
+    args: OUTPUT_ARG,
+    run: async ({ args }) => {
+      try {
+        const { markdown } = await apiGet(endpoint);
+        if (args.output === "json") {
+          writeJson({ ok: true, data: { markdown } });
+          return;
+        }
+        process.stdout.write(`${markdown.trimEnd()}
+`);
+      } catch (err) {
+        const code = err instanceof ApiError ? err.code : "INTERNAL_ERROR";
+        const message = err instanceof ApiError ? err.message : "Unexpected error";
+        if (args.output === "json") {
+          writeJson({ ok: false, error: { code, message } });
+        } else {
+          process.stderr.write(`Error: ${message}
+`);
+        }
+        process.exit(1);
+      }
+    }
+  });
+  const createArgs = {
+    name: { type: "positional", description: "Tag name (stored lowercased, spaces \u2192 hyphens)", required: true },
+    description: {
+      type: "string",
+      description: "What the tag means, so it gets applied consistently",
+      required: false
+    }
+  };
+  registerSchema({
+    command: `${command}.tags.create`,
+    description: "Create a custom media tag in the company's shared pool (images, videos and testimonials). Applies immediately. Use when no built-in or custom tag fits.",
+    args: {
+      name: { type: "string", description: "Tag name (stored lowercased, spaces \u2192 hyphens)", required: true },
+      description: createArgs.description
+    }
+  });
+  const createCommand = defineCommand({
+    meta: {
+      name: "create",
+      description: `Create a custom tag (shared by images, videos and testimonials). Applies immediately.
+
+Example: baker ${command} tags create "summer sale" --description "Assets for the summer sale campaign"`
+    },
+    args: createArgs,
+    run: async ({ args }) => {
+      const parsed = mediaTagsCreateRequestSchema.safeParse({
+        name: String(args.name ?? ""),
+        ...args.description ? { description: String(args.description) } : {}
+      });
+      if (!parsed.success) failInvalid(parsed.error.issues[0]);
+      try {
+        const data = await apiPost("/api/media-tags/create", parsed.data);
+        writeJson({
+          ok: true,
+          data,
+          hints: [
+            SHARED_POOL_HINT,
+            `Use it as \`--tags ${data.name}\`.`,
+            ...data.description ? [] : ["MISSING --description: add one with `tags update` so the tag is applied consistently."]
+          ]
+        });
+      } catch (err) {
+        fail(err);
+      }
+    }
+  });
+  registerSchema({
+    command: `${command}.tags.update`,
+    description: "Change what a custom tag means (its description). Built-in tags cannot be changed. Applies immediately.",
+    args: {
+      slug: { type: "string", description: "Custom tag name, as `tags` lists it", required: true },
+      description: { type: "string", description: "New description", required: true }
+    }
+  });
+  const updateCommand = defineCommand({
+    meta: {
+      name: "update",
+      description: `Change a custom tag's description. Built-in tags cannot be changed. Applies immediately.
+
+Example: baker ${command} tags update summer-sale --description "Assets for the 2026 summer sale"`
+    },
+    args: {
+      slug: { type: "positional", description: "Custom tag name, as `tags` lists it", required: true },
+      description: { type: "string", description: "New description", required: true }
+    },
+    run: async ({ args }) => {
+      const parsed = mediaTagsUpdateRequestSchema.safeParse({
+        slug: String(args.slug ?? ""),
+        description: String(args.description ?? "")
+      });
+      if (!parsed.success) failInvalid(parsed.error.issues[0]);
+      try {
+        const data = await apiPost("/api/media-tags/update", parsed.data);
+        writeJson({ ok: true, data, hints: [SHARED_POOL_HINT] });
+      } catch (err) {
+        fail(err);
+      }
+    }
+  });
+  registerSchema({
+    command: `${command}.tags.delete`,
+    description: "Delete a custom tag from the company's shared pool. Built-in tags cannot be deleted. Applies immediately. Confirm with the user first.",
+    args: { slug: { type: "string", description: "Custom tag name, as `tags` lists it", required: true } }
+  });
+  const deleteCommand = defineCommand({
+    meta: {
+      name: "delete",
+      description: `Delete a custom tag (shared by images, videos and testimonials). Built-in tags cannot be deleted. Applies immediately \u2014 confirm with the user first.
+
+Example: baker ${command} tags delete summer-sale`
+    },
+    args: { slug: { type: "positional", description: "Custom tag name, as `tags` lists it", required: true } },
+    run: async ({ args }) => {
+      const parsed = mediaTagsDeleteRequestSchema.safeParse({ slug: String(args.slug ?? "") });
+      if (!parsed.success) failInvalid(parsed.error.issues[0]);
+      try {
+        const data = await apiPost("/api/media-tags/delete", parsed.data);
+        writeJson({ ok: true, data, hints: [SHARED_POOL_HINT] });
+      } catch (err) {
+        fail(err);
+      }
+    }
+  });
+  return defineCommand({
+    meta: {
+      name: "tags",
+      description: `The ${label} tag taxonomy: built-in defaults plus the company's custom tags (one pool shared by images, videos and testimonials). Subcommands: list (default), create, update, delete.
+
+Examples:
+  baker ${command} tags                                   # list available tags
+  baker ${command} tags create "summer sale" --description "\u2026"
+  baker ${command} tags update summer-sale --description "\u2026"
+  baker ${command} tags delete summer-sale`
+    },
+    // Declared on the parent too: `default: "list"` dispatches the bare `tags --output json`
+    // form, and citty reads an undeclared flag's value as a subcommand name.
+    args: OUTPUT_ARG,
+    subCommands: {
+      list: listCommand,
+      create: createCommand,
+      update: updateCommand,
+      delete: deleteCommand
+    },
+    // `default`, never `run`: citty falls through to the parent's `run` after a subcommand.
+    default: "list"
+  });
+}
+
+export {
+  makeTagsCommand
+};
+//# sourceMappingURL=chunk-L3ITBLLD.js.map

package/dist/chunk-L4ATZPY2.js

@@ -0,0 +1,76 @@
+import {
+  MODEL_REGISTRY,
+  isRegisteredModel
+} from "./chunk-UQA3ASVK.js";
+
+// src/commands/canvas/scaffold-common.ts
+import { access, readFile } from "fs/promises";
+
+// src/commands/canvas/composition-path.ts
+import { existsSync } from "fs";
+import path from "path";
+function resolveShippedCanvasDir(name, startDir, exists = existsSync, maxDepth = 8) {
+  const rel = path.join("canvas", name);
+  let dir = startDir;
+  for (let i = 0; i < maxDepth; i++) {
+    const candidate = path.join(dir, rel);
+    if (exists(path.join(candidate, "meta.json"))) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.resolve(startDir, "../../../", rel);
+}
+
+// src/commands/canvas/scaffold-common.ts
+var SHIPPED_OVERLAY_COMPOSITION_DIR = resolveShippedCanvasDir(
+  "video-overlay-composition",
+  import.meta.dirname
+);
+var SHIPPED_CAPTIONS_DIR = resolveShippedCanvasDir("tiktok-captions-composition", import.meta.dirname);
+function resolveModel(kind, requested, fallback) {
+  const model = requested ? String(requested) : fallback;
+  if (isRegisteredModel(kind, model)) return model;
+  const known = Object.keys(MODEL_REGISTRY[kind]).join(", ");
+  throw new Error(`"${model}" is not a ${kind} model. Use one of: ${known}`);
+}
+async function loadAssetText(ref, label) {
+  const r = ref;
+  if (typeof r?.path === "string") return readFile(r.path, "utf8");
+  if (typeof r?.url === "string") {
+    const res = await fetch(r.url);
+    if (!res.ok) throw new Error(`failed to fetch ${label} (${res.status})`);
+    return res.text();
+  }
+  throw new Error(`${label}: output had no readable path or url`);
+}
+function parseElements(raw) {
+  const parsed = JSON.parse(raw);
+  if (Array.isArray(parsed)) return parsed;
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed.elements)) {
+    return parsed.elements;
+  }
+  return [];
+}
+function fail(code, message, fix) {
+  process.stderr.write(`${JSON.stringify({ ok: false, error: { code, message, ...fix ? { fix } : {} } }, null, 2)}
+`);
+  process.exit(2);
+}
+function fileExists(target) {
+  return access(target).then(
+    () => true,
+    () => false
+  );
+}
+
+export {
+  SHIPPED_OVERLAY_COMPOSITION_DIR,
+  SHIPPED_CAPTIONS_DIR,
+  resolveModel,
+  loadAssetText,
+  parseElements,
+  fail,
+  fileExists
+};
+//# sourceMappingURL=chunk-L4ATZPY2.js.map

package/dist/chunk-L6UWXOHS.js

@@ -0,0 +1,26 @@
+import {
+  DEFAULT_VIDEO_GENERATE_MODEL,
+  clipAudioMode,
+  spokenWordsIn
+} from "./chunk-UQA3ASVK.js";
+
+// src/commands/studio/avatarModel.ts
+function pinnedModelHint(input) {
+  if (!input.avatar || !input.model) return null;
+  if (input.model === DEFAULT_VIDEO_GENERATE_MODEL) return null;
+  const speaks = input.generateAudio ?? true;
+  if (!speaks) return null;
+  return `You pinned --model ${input.model} on a speaking avatar. Without it this clip routes to ${DEFAULT_VIDEO_GENERATE_MODEL}, which was chosen for exactly this case: the better picture, both orientations, and audio always on. Drop --model unless the user asked for a specific one \u2014 and note ${input.model} may not take the length or the reference you are counting on.`;
+}
+function silentModelHint(model, prompt) {
+  if (!model || !prompt) return null;
+  if (clipAudioMode(model) !== "never") return null;
+  if (spokenWordsIn(prompt) === 0) return null;
+  return `${model} renders no audio \u2014 the line in this prompt will be mouthed and never heard. For a shot where someone speaks use ${DEFAULT_VIDEO_GENERATE_MODEL} (audio always on), or alibaba/wan-3.0 past 10 seconds. Keep this model for shots with no voice in them.`;
+}
+
+export {
+  pinnedModelHint,
+  silentModelHint
+};
+//# sourceMappingURL=chunk-L6UWXOHS.js.map