@koda-sl/baker-cli 0.501.0-dev.6e96f50b9 → 0.502.0

package/dist/chunk-DVUEFCOG.js

@@ -1,122 +0,0 @@
-import {
-  prepareCanvas,
-  unsuppliedPlaceholderAssets
-} from "./chunk-JD2PWX7P.js";
-import {
-  isSourceStale
-} from "./chunk-MWD6JTOY.js";
-
-// src/commands/canvas/render-state.ts
-import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
-import path from "path";
-var RENDER_STATE_DIR = ".rendered";
-function statePath(canvasRoot, slug) {
-  return path.join(canvasRoot, RENDER_STATE_DIR, `${slug}.json`);
-}
-async function readRenderState(canvasRoot, slug) {
-  try {
-    const parsed = JSON.parse(await readFile(statePath(canvasRoot, slug), "utf8"));
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-async function latestVersion(canvasRoot, slug) {
-  return (await readRenderState(canvasRoot, slug)).rendered?.runId ?? null;
-}
-async function updateRenderState(canvasRoot, slug, patch) {
-  try {
-    const next = { ...await readRenderState(canvasRoot, slug), ...patch };
-    await mkdir(path.join(canvasRoot, RENDER_STATE_DIR), { recursive: true });
-    await writeFile(statePath(canvasRoot, slug), `${JSON.stringify(next, null, 2)}
-`, "utf8");
-  } catch {
-  }
-}
-async function recordRenderAttempt(canvasRoot, slug, sourceSha) {
-  if (!sourceSha) return;
-  await updateRenderState(canvasRoot, slug, { attempted: { sourceSha, at: Date.now() } });
-}
-async function recordRendered(canvasRoot, slug, sourceSha, runId, drawn = {}) {
-  if (!sourceSha) return;
-  await updateRenderState(canvasRoot, slug, {
-    rendered: { sourceSha, runId, at: Date.now() },
-    ...drawn.prompt !== void 0 ? { prompt: drawn.prompt } : {},
-    ...drawn.anchor ? { anchor: drawn.anchor } : {},
-    ...drawn.idea ? { idea: drawn.idea } : {},
-    lastFix: drawn.lastFix,
-    picture: drawn.picture,
-    ...drawn.seriesLeadRun ? { seriesLeadRun: drawn.seriesLeadRun } : {}
-  });
-}
-async function recordSeen(canvasRoot, slug, seen) {
-  await updateRenderState(canvasRoot, slug, { seen });
-}
-async function recordIdeaLines(canvasRoot, slug, idea) {
-  if ((await readRenderState(canvasRoot, slug)).idea) return;
-  await updateRenderState(canvasRoot, slug, { idea });
-}
-async function recordReviewOutcome(canvasRoot, slug, outcome) {
-  await updateRenderState(canvasRoot, slug, outcome);
-}
-async function recordSeriesLeadRun(canvasRoot, slug, leadRunId) {
-  await updateRenderState(canvasRoot, slug, { seriesLeadRun: leadRunId });
-}
-async function recordSnapshot(canvasRoot, slug, snapshot) {
-  await updateRenderState(canvasRoot, slug, { snapshot });
-}
-function isRenderStale(state, currentSourceSha) {
-  if (!state.rendered) return false;
-  if (!isSourceStale(currentSourceSha, state.rendered.sourceSha)) return false;
-  return state.attempted?.sourceSha !== currentSourceSha;
-}
-async function staleCreatives(workspaceRoot) {
-  const creativesDir = path.join(workspaceRoot, "src", "creatives");
-  const canvasRoot = path.join(workspaceRoot, "canvas");
-  let slugs;
-  try {
-    slugs = (await readdir(creativesDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch {
-    return [];
-  }
-  const stale = [];
-  for (const slug of slugs.sort()) {
-    const state = await readRenderState(canvasRoot, slug);
-    if (!state.rendered) continue;
-    const canvasPath = path.join(creativesDir, slug, `${slug}.canvas.json`);
-    let prepared;
-    try {
-      prepared = await prepareCanvas(canvasPath, { write: false });
-    } catch {
-      continue;
-    }
-    if (unsuppliedPlaceholderAssets(prepared.fileGraph).length > 0) continue;
-    const current = prepared.sourceSha;
-    if (!current || !isRenderStale(state, current)) continue;
-    stale.push({
-      slug,
-      canvasPath: path.relative(workspaceRoot, canvasPath).split(path.sep).join("/"),
-      renderedRunId: state.rendered.runId,
-      sourceSha: current
-    });
-  }
-  return stale;
-}
-async function clearLegacyDirtyMarker(canvasRoot, slug) {
-  await rm(path.join(canvasRoot, ".dirty", `${slug}.json`), { force: true }).catch(() => void 0);
-}
-
-export {
-  readRenderState,
-  latestVersion,
-  recordRenderAttempt,
-  recordRendered,
-  recordSeen,
-  recordIdeaLines,
-  recordReviewOutcome,
-  recordSeriesLeadRun,
-  recordSnapshot,
-  staleCreatives,
-  clearLegacyDirtyMarker
-};
-//# sourceMappingURL=chunk-DVUEFCOG.js.map

package/dist/chunk-ERGEZPJH.js

@@ -1,167 +0,0 @@
-import {
-  parseRefExpr
-} from "./chunk-B5JQM24Z.js";
-import {
-  collectAssetRefLikes,
-  isPersistedAssetRef
-} from "./chunk-FOMFU2RX.js";
-
-// src/commands/canvas/run-record.ts
-import path from "path";
-var MAX_RUN_NODES = 200;
-var MAX_OUTPUTS_PER_NODE = 10;
-var MAX_FINAL_OUTPUTS = 10;
-var MAX_NODE_FACTS_CHARS = 4096;
-var MAX_CREATIVE_SLUG_LENGTH = 100;
-function creativeSlugFromCanvasPath(filePath) {
-  const normalized = filePath.split(path.sep).join("/");
-  const match = normalized.match(/(?:^|\/)src\/creatives\/([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\//);
-  const slug = match?.[1] ?? null;
-  return slug && slug.length <= MAX_CREATIVE_SLUG_LENGTH ? slug : null;
-}
-function finalOutputLabelsFromCanvas(parsed) {
-  const canvas = parsed;
-  const outputNodeId = canvas?.output?.node;
-  if (typeof outputNodeId !== "string" || !Array.isArray(canvas?.nodes)) return null;
-  const node = canvas.nodes.find((n) => n?.id === outputNodeId);
-  if (node?.type !== "collect") return null;
-  const explicit = node.params?.labels;
-  if (Array.isArray(explicit) && explicit.every((l) => typeof l === "string")) {
-    return { nodeId: outputNodeId, labels: explicit };
-  }
-  const images = node.inputs?.images;
-  if (!Array.isArray(images)) return null;
-  const labels = images.map((entry) => {
-    if (typeof entry !== "string") return void 0;
-    return parseRefExpr(entry)?.nodeId;
-  });
-  return { nodeId: outputNodeId, labels };
-}
-var OUTPUT_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "json", "text", "font"]);
-function toRecordOutput(slot, value, label) {
-  const refs = collectAssetRefLikes(value);
-  const ref = refs.length === 1 ? refs[0] : null;
-  if (!ref || !isPersistedAssetRef(ref)) return null;
-  const kind = typeof ref.kind === "string" && OUTPUT_KINDS.has(ref.kind) ? ref.kind : null;
-  if (!kind) return null;
-  return {
-    slot,
-    label,
-    kind,
-    sha256: ref.sha256,
-    url: ref.url,
-    mime: ref.mime,
-    width: typeof ref.width === "number" ? ref.width : void 0,
-    height: typeof ref.height === "number" ? ref.height : void 0,
-    durationMs: typeof ref.duration_ms === "number" ? ref.duration_ms : void 0
-  };
-}
-function nodeOutputsToRecord(nodeOutputs, labels) {
-  const out = [];
-  for (const [slot, value] of Object.entries(nodeOutputs)) {
-    if (Array.isArray(value)) {
-      value.forEach((item, i) => {
-        const rec = toRecordOutput(`${slot}#${i}`, item, labels?.[i]);
-        if (rec) out.push(rec);
-      });
-    } else {
-      const rec = toRecordOutput(slot, value);
-      if (rec) out.push(rec);
-    }
-  }
-  return out.slice(0, MAX_OUTPUTS_PER_NODE);
-}
-function finalOutputsToRecord(output, labels) {
-  if (Array.isArray(output)) {
-    return output.map((item, i) => toRecordOutput(`final#${i}`, item, labels?.[i])).filter((rec2) => rec2 !== null).slice(0, MAX_FINAL_OUTPUTS);
-  }
-  const rec = toRecordOutput("final", output);
-  return rec ? [rec] : [];
-}
-function finalFiles(output, labels) {
-  const items = Array.isArray(output) ? output : [output];
-  const files = {};
-  items.forEach((item, i) => {
-    const ref = collectAssetRefLikes(item)[0];
-    if (ref && typeof ref.path === "string") files[labels?.[i] ?? `final#${i}`] = ref.path;
-  });
-  return files;
-}
-function withFacts(nodeOutputs) {
-  const facts = nodeOutputs.facts;
-  if (facts === void 0 || facts === null) return {};
-  const json = JSON.stringify(facts);
-  return json.length <= MAX_NODE_FACTS_CHARS ? { facts: json } : {};
-}
-function buildRunRecord(result, meta, plan, finalLabels) {
-  const nodes = result.node_runs.slice(0, MAX_RUN_NODES).map((run) => {
-    const planned = plan?.get(run.node_id);
-    return {
-      nodeId: run.node_id,
-      nodeType: run.node_type,
-      cached: run.cached,
-      credits: run.credits,
-      durationMs: run.duration_ms,
-      outputs: nodeOutputsToRecord(
-        result.outputs_by_node[run.node_id] ?? {},
-        run.node_id === finalLabels?.nodeId ? finalLabels.labels : void 0
-      ),
-      deps: planned?.deps,
-      status: plan ? "completed" : void 0,
-      paramsPreview: planned?.paramsPreview,
-      ...planned?.role !== void 0 ? { role: planned.role } : {},
-      ...withFacts(result.outputs_by_node[run.node_id] ?? {})
-    };
-  });
-  const finalOutputs = finalOutputsToRecord(result.output, finalLabels?.labels);
-  return {
-    runId: result.run_id,
-    ...meta,
-    status: "completed",
-    stats: {
-      totalNodes: result.stats.total_nodes,
-      cachedNodes: result.stats.cached_nodes,
-      totalCredits: result.stats.total_credits,
-      durationMs: result.stats.duration_ms
-    },
-    nodes,
-    finalOutputs: finalOutputs.length > 0 ? finalOutputs : void 0,
-    // Sent whenever the review RAN, empty list included. Sending it only when there
-    // were findings makes a clean render and an unreviewed one look identical in the
-    // record — which is the exact ambiguity this field was added to remove: proving a
-    // review had happened once meant re-running a cached canvas and reading raw JSON.
-    // Only the fields the backend keeps: a static review's typed fields (`kind`) stay in the CLI.
-    ...meta.review ? { review: meta.review.slice(0, 40).map(({ severity, what, scene }) => ({ severity, what, ...scene ? { scene } : {} })) } : {}
-  };
-}
-function buildInitialRunRecord(runId, meta) {
-  return {
-    runId,
-    ...meta,
-    status: "running",
-    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
-    nodes: []
-  };
-}
-function buildFailedRunRecord(runId, errorMessage, meta) {
-  return {
-    runId,
-    ...meta,
-    status: "failed",
-    errorMessage: errorMessage.slice(0, 2e3),
-    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
-    nodes: []
-  };
-}
-
-export {
-  creativeSlugFromCanvasPath,
-  finalOutputLabelsFromCanvas,
-  nodeOutputsToRecord,
-  finalFiles,
-  withFacts,
-  buildRunRecord,
-  buildInitialRunRecord,
-  buildFailedRunRecord
-};
-//# sourceMappingURL=chunk-ERGEZPJH.js.map

package/dist/chunk-F6P6GGWB.js

@@ -1,156 +0,0 @@
-import {
-  Phrases,
-  RULE_APPLIES,
-  RULE_KINDS,
-  RULE_STRENGTHS
-} from "./chunk-X4A7NEBZ.js";
-import {
-  holdWorkspaceSpend
-} from "./chunk-E44NXCTL.js";
-import {
-  askAboutText
-} from "./chunk-PSYAT3ZM.js";
-import {
-  CREATIVE_FEEDBACK_REASON_LABELS
-} from "./chunk-MWD6JTOY.js";
-
-// src/commands/creatives/rule-candidate.ts
-import { createHash } from "crypto";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import path from "path";
-import { z } from "zod";
-var optionalPhrases = Phrases.optional().catch(void 0);
-var Draft = z.object({
-  because: z.string().trim().min(3).max(400),
-  text: z.string().trim().min(1).max(300),
-  strength: z.enum(RULE_STRENGTHS).catch("must"),
-  applies: z.enum(RULE_APPLIES).catch("any"),
-  language: z.string().trim().regex(/^[a-z]{2,3}$/).optional().catch(void 0),
-  kinds: z.array(z.enum(RULE_KINDS)).optional().catch(void 0),
-  platforms: optionalPhrases,
-  forbid: optionalPhrases,
-  require: optionalPhrases,
-  allow: optionalPhrases,
-  people: z.literal("real").optional().catch(void 0)
-});
-function parseDrafts(answer) {
-  const rules = answer?.rules;
-  if (!Array.isArray(rules)) return [];
-  return rules.slice(0, MAX_DRAFTS).flatMap((raw) => {
-    const draft = Draft.safeParse(raw);
-    if (!draft.success) return [];
-    const { because: _because, ...rule } = draft.data;
-    return [
-      Object.fromEntries(
-        Object.entries(rule).filter(([, v]) => v !== void 0 && !(Array.isArray(v) && v.length === 0))
-      )
-    ];
-  });
-}
-var MAX_DRAFTS = 3;
-function draftRulesPrompt(note, ad) {
-  const where = [ad.kind ? `a ${ad.kind} ad` : "an ad", ad.platform ? `for ${ad.platform}` : ""].filter(Boolean).join(" ");
-  return [
-    `A person rejected ${where} and said, in their own words:`,
-    `"""${note}"""`,
-    "",
-    "List only the standing rules this note states for EVERY future ad of the company (at most 3). Most notes state none: they ask for changes to this ad (fix a word, move the logo, speed up a scene, redo the pieces), and a change to this ad is never a rule, however it is phrased. A rule is standing only when the note itself says it holds beyond this ad (always, never, in every video, in these creatives, these mistakes keep happening, it is the format of the programme, the rule of the other pieces), or it corrects how the company or what it sells must always be named.",
-    "For each rule, quote in `because` the note's own words that make it hold beyond this ad; a rule you cannot quote that for is not a rule. Return JSON only:",
-    '{"rules": [{"because": string, "text": string, "strength": "never" | "must" | "prefer", "applies": "copy" | "picture" | "cast" | "logo" | "voice" | "sound" | "subtitles" | "any", "language": string, "kinds": ["static" | "video"], "platforms": string[], "forbid": string[], "require": string[], "allow": string[], "people": "real" | null}]}',
-    "- text: the rule in one short sentence, in the note's own language and close to its words.",
-    '- strength: "never" for a ban, "must" for something every ad has to do, "prefer" for a taste.',
-    '- applies: what of the ad it is about ("copy" for its words, "picture", "cast" for who appears, "logo", "voice", "sound", "subtitles"), else "any".',
-    `- language: the note's language as a two-letter code ("es").`,
-    '- kinds and platforms: only when the note limits the rule to them ("en estos creativos de linkedin" gives platforms ["linkedin"]); else [].',
-    `- forbid: the exact words the rule bans in the ad's words, only when a word or phrase decides it ("100 % online", not "online" gives forbid ["online"], allow ["100 % online"]); else []. require: words every ad must say; usually []. allow: the right phrase that contains a banned word.`,
-    '- people: "real" only when the rule is that no AI-made or invented people appear; else null.',
-    'Return {"rules": []} when the note states no standing rule.'
-  ].join("\n");
-}
-var RULE_DRAFT_MODEL = "google/gemini-3.5-flash";
-var DRAFT_REQUEST = {
-  provider: { order: ["google-vertex"], allow_fallbacks: false },
-  seed: 0,
-  reasoning: { effort: "low" },
-  response_format: { type: "json_object" }
-};
-var DRAFT_TIMEOUT_MS = 3e4;
-function modelRuleDrafter(cacheDir) {
-  return async (note, ad) => {
-    const prompt = draftRulesPrompt(note, ad);
-    const key = createHash("sha256").update(JSON.stringify([RULE_DRAFT_MODEL, prompt])).digest("hex").slice(0, 16);
-    const file = path.join(cacheDir, "rule-drafts", `${key}.json`);
-    const cached = await readFile(file, "utf8").then(
-      (raw) => parseDrafts(JSON.parse(raw)),
-      () => null
-    );
-    if (cached) return cached;
-    const spent = [];
-    const answer = await askAboutText(RULE_DRAFT_MODEL, prompt, (u) => spent.push(u), {
-      timeoutMs: DRAFT_TIMEOUT_MS,
-      request: DRAFT_REQUEST
-    }).catch(() => null);
-    await holdWorkspaceSpend(spent);
-    if (answer === null) return [];
-    await mkdir(path.dirname(file), { recursive: true }).catch(() => void 0);
-    await writeFile(file, JSON.stringify(answer), "utf8").catch(() => void 0);
-    return parseDrafts(answer);
-  };
-}
-async function ruleCandidates(note, ad, draft) {
-  const text = note?.trim();
-  if (!text) return [];
-  return await draft(text, ad).catch(() => []);
-}
-var candidatesDir = (cacheDir) => path.join(cacheDir, "rule-candidates");
-async function saveCandidates(cacheDir, candidates) {
-  await mkdir(candidatesDir(cacheDir), { recursive: true });
-  return await Promise.all(
-    candidates.map(async (c) => {
-      const id = `rc-${createHash("sha256").update(JSON.stringify(c)).digest("hex").slice(0, 8)}`;
-      await writeFile(path.join(candidatesDir(cacheDir), `${id}.json`), JSON.stringify(c), "utf8");
-      return id;
-    })
-  );
-}
-async function loadCandidate(cacheDir, id) {
-  if (!/^rc-[0-9a-f]{8}$/.test(id)) return null;
-  return await readFile(path.join(candidatesDir(cacheDir), `${id}.json`), "utf8").then(
-    (raw) => JSON.parse(raw),
-    () => null
-  );
-}
-var REPEATED_ON = 2;
-var REPEATED_NOTES = 3;
-function repeatedReasons(notes, reasons, slug) {
-  return reasons.flatMap((reason) => {
-    const others = notes.filter((n) => n.creative !== slug && n.reasons.includes(reason));
-    const creatives = new Set(others.map((n) => n.creative)).size;
-    return creatives >= REPEATED_ON ? [
-      {
-        label: CREATIVE_FEEDBACK_REASON_LABELS[reason],
-        creatives,
-        notes: [...new Set(others.map((n) => n.note))].slice(0, REPEATED_NOTES)
-      }
-    ] : [];
-  });
-}
-function ruleCandidateHints(drafted, repeated) {
-  const asks = drafted.map(
-    (d) => `Their words state a rule for every ad: "${d.text}". Ask them once, in their language: make this a rule for every ad from now on? Only on yes: \`baker creatives rules add --candidate ${d.id}\` (reword it with --text if they correct it). On no, never ask again in this chat.`
-  );
-  const patterns = repeated.map(
-    (r) => `"${r.label}" was also the reason on ${r.creatives} other ads (their words: ${r.notes.map((n) => `"${n}"`).join("; ")}). ${drafted.length > 0 ? "Say so when you ask." : 'Ask them once whether there is a rule for every ad behind it; on yes, `baker creatives rules add --text "<the rule, in their words>" \u2026`.'}`
-  );
-  return [...asks, ...patterns];
-}
-
-export {
-  modelRuleDrafter,
-  ruleCandidates,
-  saveCandidates,
-  loadCandidate,
-  repeatedReasons,
-  ruleCandidateHints
-};
-//# sourceMappingURL=chunk-F6P6GGWB.js.map

package/dist/chunk-FHBDDVL4.js

@@ -1,66 +0,0 @@
-import {
-  recordIdeaLines
-} from "./chunk-DVUEFCOG.js";
-import {
-  anchorLines,
-  readIdeaAnchor
-} from "./chunk-JD2PWX7P.js";
-import {
-  findWorkspaceRoot
-} from "./chunk-EJGAJHLB.js";
-
-// src/commands/creatives/idea-hint.ts
-import path from "path";
-function present(fields) {
-  const said = Object.entries(fields).filter(([, v]) => v !== void 0 && !(Array.isArray(v) && v.length === 0));
-  return Object.fromEntries(said);
-}
-function anchorOut(view, full) {
-  const reference = view.reference ? {
-    ...present({ adId: view.reference.adId, advertiser: view.advertiser }),
-    carry: view.reference.carry,
-    mustKeep: view.reference.mustKeep
-  } : void 0;
-  const compact = present({
-    message: view.message,
-    language: view.language,
-    reference,
-    seriesLead: view.seriesLead,
-    accent: view.accent,
-    cast: view.cast,
-    who: view.who,
-    survives: view.survives
-  });
-  if (!full) return compact;
-  return {
-    ...compact,
-    ...present({ why: view.why, voices: view.voices, voiceIds: view.voiceIds, route: view.route }),
-    changes: view.changes
-  };
-}
-function ideaHint(view) {
-  return `Its idea: ${anchorLines(view).join(" \xB7 ").replace(
-    /[.!?…]+$/u,
-    ""
-  )}. An edit keeps it: change exactly what they named; a change of the idea they asked for is one line under "## Changes" in _definition.md, the reason after the dash.`;
-}
-function withAnchor(response, view, opts) {
-  return {
-    ...response,
-    data: { ...response.data, anchor: anchorOut(view, opts.full) },
-    hints: [ideaHint(view), ...response.hints ?? []]
-  };
-}
-async function readCreativeIdea(slug) {
-  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
-  const read = await readIdeaAnchor(path.join(root, "src", "creatives", slug));
-  if (!read) return null;
-  await recordIdeaLines(path.join(root, "canvas"), slug, anchorLines(read.view)).catch(() => void 0);
-  return read.view;
-}
-
-export {
-  withAnchor,
-  readCreativeIdea
-};
-//# sourceMappingURL=chunk-FHBDDVL4.js.map