@koda-sl/baker-cli 0.495.0 → 0.497.0

package/dist/chunk-L7WMS5PW.js

@@ -0,0 +1,172 @@
+import {
+  ACTION_TEMP_ID_PREFIX
+} from "./chunk-O37VU7FG.js";
+import {
+  ApiError
+} from "./chunk-6YLNY6CK.js";
+import {
+  writeJson
+} from "./chunk-QANGHND7.js";
+
+// src/commands/actions/tagError.ts
+var UNKNOWN_TAG_RE = /Unknown action tag\(s\): ([^.]+)\. Valid tags: ([^.]+)\./;
+function splitSlugs(list) {
+  return list.split(",").map((slug) => slug.trim()).filter((slug) => slug.length > 0);
+}
+function actionTagFix(message) {
+  const match = UNKNOWN_TAG_RE.exec(message);
+  if (!match) {
+    return null;
+  }
+  const [, unknownList, validList] = match;
+  const unknownTags = splitSlugs(unknownList ?? "");
+  const validTags = splitSlugs(validList ?? "");
+  const first = unknownTags[0];
+  if (first === void 0 || validTags.length === 0) {
+    return null;
+  }
+  return {
+    action: "retry_with_a_valid_tag",
+    explanation: `The tag(s) ${unknownTags.join(", ")} are not in this company's taxonomy. \`validTags\` below is the complete accepted set \u2014 pick from it and re-run the same command. Only mint a new tag when none of them names this work; a near-duplicate of an existing tag splits the backlog's filter instead of extending it.`,
+    unknownTags,
+    validTags,
+    mintCommand: `baker actions tags create --slug ${first} --description "<what ${first} groups>"`,
+    listCommand: "baker actions tags list"
+  };
+}
+
+// src/commands/actions/shared.ts
+function writeOk(data) {
+  writeJson({ ok: true, data: data ?? null });
+}
+function failValidation(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function failApi(err) {
+  if (err instanceof ApiError) {
+    const fix = actionTagFix(err.message);
+    writeJson({ ok: false, error: { code: err.code, message: err.message, ...fix ? { fix } : {} } });
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function generateTempId() {
+  return `${ACTION_TEMP_ID_PREFIX}${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function isTempId(id) {
+  return id.startsWith(ACTION_TEMP_ID_PREFIX);
+}
+function parseTagList(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const tags = value.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  return [...new Set(tags)];
+}
+var ACTION_PRIORITIES = ["urgent", "high", "medium", "low"];
+function parsePriority(value, { allowClear }) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    failValidation(
+      `--priority must be one of: ${ACTION_PRIORITIES.join(", ")}${allowClear ? ", or 'none' to clear" : ""}.`
+    );
+  }
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "") {
+    if (allowClear) {
+      return null;
+    }
+    return void 0;
+  }
+  if (allowClear && (trimmed === "none" || trimmed === "clear")) {
+    return null;
+  }
+  if (ACTION_PRIORITIES.includes(trimmed)) {
+    return trimmed;
+  }
+  failValidation(
+    `Unknown --priority "${value}". Expected one of: ${ACTION_PRIORITIES.join(", ")}${allowClear ? ", or 'none' to clear" : ""}.`
+  );
+}
+var FAN_OUT_NUDGE_THRESHOLD = 2;
+var FAN_OUT_THRESHOLD = 3;
+function buildCreateHints({
+  advisory,
+  description,
+  tempId,
+  tags,
+  prioritySet,
+  draftCreateCount
+}) {
+  const hints = [];
+  if (advisory) {
+    hints.push(
+      `${advisory.hint} If nothing actually blocks it: baker actions draft remove ${tempId}, then do the work.`
+    );
+  }
+  if (draftCreateCount >= FAN_OUT_THRESHOLD) {
+    hints.push(
+      `${draftCreateCount} Tasks are staged in this chat. Re-read them with \`baker actions draft\`: can any be done now with a surface you already have, and do any two touch the same system (same container, same campaign, same page)? Those belong in ONE Task \u2014 fold them together with \`baker actions update\` and drop the extras with \`baker actions draft remove <tempId>\`.`
+    );
+  } else if (draftCreateCount === FAN_OUT_NUDGE_THRESHOLD) {
+    hints.push(
+      `Second Task staged in this chat. If these two land on the same system (same container, same campaign, same page) they are ONE Task \u2014 fold them with \`baker actions update\` and drop the extra with \`baker actions draft remove ${tempId}\`.`
+    );
+  }
+  hints.push(`Link dependencies: baker actions link --blocker <id> --blocked ${tempId}`);
+  if (!description) {
+    hints.push("Add description: baker actions update <tempId> --description '...' (what/why/where/done-when)");
+  }
+  if (!tags || tags.length === 0) {
+    hints.push(
+      "MISSING --tags. This action is invisible to the backlog's tag filter. Re-run with --tags <slug,...> (`baker actions tags list` for the taxonomy, `baker actions tags create --slug <slug>` to mint) \u2014 or `baker actions update <tempId> --tags <slug,...>`."
+    );
+  }
+  if (!prioritySet) {
+    hints.push(
+      `MISSING --priority. Without it this action ranks as 'normal' (medium) in the do-first ordering, so urgent/high client work won't surface first. Re-run with --priority ${ACTION_PRIORITIES.join("|")} \u2014 or \`baker actions update <tempId> --priority <level>\`.`
+    );
+  }
+  return hints;
+}
+var ACTIONS_LIST_DEFAULT_LIMIT = 500;
+function buildListHints({ returned, limit }) {
+  if (returned < limit) {
+    return [];
+  }
+  return [
+    `This list is capped at ${limit} Tasks and came back full, so older Tasks exist that are NOT shown. Do not treat it as the whole backlog \u2014 re-run with --limit ${limit * 2} (or narrow with --status / --search).`
+  ];
+}
+function buildGetHints(detail) {
+  if (detail?.action.status !== "pending" || detail.activeChat !== null) {
+    return [];
+  }
+  return [
+    `If you are working on this Task in this chat, claim it first so the Tasks page shows it in progress: baker actions claim ${detail.action._id}`
+  ];
+}
+
+export {
+  writeOk,
+  failValidation,
+  failApi,
+  generateTempId,
+  isTempId,
+  parseTagList,
+  ACTION_PRIORITIES,
+  parsePriority,
+  buildCreateHints,
+  ACTIONS_LIST_DEFAULT_LIMIT,
+  buildListHints,
+  buildGetHints
+};
+//# sourceMappingURL=chunk-L7WMS5PW.js.map

package/dist/chunk-LBRO4MTL.js

@@ -0,0 +1,19 @@
+import {
+  latestVersion
+} from "./chunk-I24YT2KG.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-XRIM7NYV.js";
+
+// src/commands/creatives/version-of.ts
+import path from "path";
+async function versionOf(slug, run) {
+  if (typeof run === "string" && run.trim()) return run.trim();
+  const canvas = path.join("src", "creatives", slug, `${slug}.canvas.json`);
+  return await latestVersion(canvasOutputsRoot(canvas), slug) ?? void 0;
+}
+
+export {
+  versionOf
+};
+//# sourceMappingURL=chunk-LBRO4MTL.js.map

package/dist/chunk-LNRPOULW.js

@@ -0,0 +1,224 @@
+import {
+  nodeParamsPreview
+} from "./chunk-RJZS4XDJ.js";
+import {
+  creativeSlugFromCanvasPath
+} from "./chunk-QRLTVJ6F.js";
+import {
+  parseDefinitionDelivery,
+  parseDefinitionSeriesPlace,
+  parseDefinitionSourceFields,
+  parseDefinitionStrategyFields,
+  prepareCanvas
+} from "./chunk-XXDF25BW.js";
+import {
+  BackendClient
+} from "./chunk-B7GF34FU.js";
+import {
+  nodeDependencies
+} from "./chunk-OL7JS4NG.js";
+import {
+  requireCredentialsFromEnv
+} from "./chunk-U7YR5CZL.js";
+
+// src/commands/canvas/sync-definition.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path from "path";
+import { parseDocument } from "yaml";
+import { defineCommand } from "citty";
+
+// src/commands/canvas/definition-graph.ts
+var MAX_NODES = 300;
+var PREVIEWABLE_INGEST_EXPECTS = /* @__PURE__ */ new Set(["image"]);
+function nodeInputPreviewUrl(type, params) {
+  if (type !== "ingest" || !params || typeof params !== "object") return void 0;
+  const p = params;
+  if (p.source !== "url" || typeof p.url !== "string") return void 0;
+  if (!/^https?:\/\//i.test(p.url)) return void 0;
+  if (typeof p.expect === "string" && !PREVIEWABLE_INGEST_EXPECTS.has(p.expect)) return void 0;
+  return p.url;
+}
+function canvasToDefinitionGraph(canvas) {
+  const rawNodes = canvas?.nodes;
+  if (!Array.isArray(rawNodes)) return null;
+  const parsed = [];
+  for (const raw of rawNodes) {
+    const id = raw?.id;
+    const type = raw?.type;
+    if (typeof id !== "string" || typeof type !== "string") continue;
+    parsed.push({ id, type, inputs: raw.inputs, params: raw.params });
+    if (parsed.length >= MAX_NODES) break;
+  }
+  if (parsed.length === 0) return null;
+  const ids = new Set(parsed.map((n) => n.id));
+  const nodes = parsed.map(({ id, type, inputs, params }) => {
+    const deps = nodeDependencies({ id, inputs, params }, ids);
+    deps.delete(id);
+    const depList = [...deps];
+    const paramsPreview = nodeParamsPreview(params, depList);
+    const base = { id, type };
+    if (depList.length > 0) base.deps = depList;
+    if (paramsPreview) base.paramsPreview = paramsPreview;
+    const inputPreviewUrl = nodeInputPreviewUrl(type, params);
+    if (inputPreviewUrl) base.inputPreviewUrl = inputPreviewUrl;
+    return base;
+  });
+  const rawOutput = canvas?.output;
+  const outNode = rawOutput?.node;
+  const outSlot = rawOutput?.output;
+  const output = typeof outNode === "string" && typeof outSlot === "string" ? { node: outNode, output: outSlot } : void 0;
+  return { nodes, output };
+}
+
+// src/commands/canvas/sync-definition.ts
+function buildDefinitionSyncPayload(input, graph, chatId) {
+  const { canvas: _canvas, ...fields } = input;
+  return Object.fromEntries([
+    ...Object.entries(fields).filter(([, v]) => v !== void 0),
+    ["graph", graph],
+    ["chatId", chatId]
+  ]);
+}
+async function readDefinitionSourceFields(canvasPath) {
+  try {
+    return parseDefinitionSourceFields(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionPlatforms(canvasPath) {
+  const raw = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8").catch(() => null);
+  const delivery = raw === null ? null : parseDefinitionDelivery(raw);
+  return delivery ? { platforms: delivery.platforms ?? null } : {};
+}
+async function readDefinitionBody(canvasPath) {
+  try {
+    return { definition: await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8") };
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionTitle(canvasPath) {
+  try {
+    const raw = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8");
+    const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+    const doc = match ? parseDocument(match[1] ?? "") : null;
+    const title = doc && doc.errors.length === 0 ? doc.get("title") : void 0;
+    return typeof title === "string" && title.trim() ? title.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readDefinitionStrategyFields(canvasPath) {
+  try {
+    return parseDefinitionStrategyFields(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionSeriesPlace(canvasPath) {
+  try {
+    return parseDefinitionSeriesPlace(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+async function syncCreativeDefinitionBestEffort(input) {
+  const chatId = process.env.BAKER_CHAT_ID;
+  if (!chatId) return;
+  const graph = canvasToDefinitionGraph(input.canvas);
+  if (!graph || graph.nodes.length === 0) return;
+  try {
+    const creds = requireCredentialsFromEnv();
+    const client = new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey });
+    await client.syncCreativeDefinition(buildDefinitionSyncPayload(input, graph, chatId));
+    process.stdout.write(`[definition] synced workflow graph (${graph.nodes.length} nodes) \u2014 view it in the dashboard
+`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`[warn] workflow graph not synced (${msg})
+`);
+  }
+}
+async function resolveCanvasPath(inputPath) {
+  const resolved = path.resolve(inputPath);
+  let dir = resolved;
+  try {
+    if ((await stat(resolved)).isFile()) {
+      if (resolved.endsWith(".canvas.json")) return resolved;
+      dir = path.dirname(resolved);
+    }
+  } catch {
+    dir = resolved.endsWith(".canvas.json") ? path.dirname(resolved) : resolved;
+  }
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return null;
+  }
+  const canvases = entries.filter((name) => name.endsWith(".canvas.json"));
+  const slug = creativeSlugFromCanvasPath(`${dir}/x/`);
+  const chosen = (slug ? canvases.find((name) => name === `${slug}.canvas.json`) : void 0) ?? canvases[0];
+  return chosen ? path.join(dir, chosen) : null;
+}
+var syncDefinitionCommand = defineCommand({
+  meta: {
+    name: "sync-definition",
+    description: "Push a creative's current node-graph + input thumbnails to the dashboard without rendering. The graph has the creative's blueprint applied (prompt.json and scenes/*.json edits), exactly as `run` would render it, without changing any file. Runs automatically when you edit a creative's canvas.json or prompt.json."
+  },
+  args: {
+    file: {
+      type: "positional",
+      required: true,
+      description: "A path under src/creatives/<slug>/ (the .canvas.json, its prompt.json, or the folder)"
+    },
+    title: {
+      type: "boolean",
+      description: "Also record the title its _definition.md gives. Only for a creative just made from another (a series ad, a translation), never on an edit re-sync."
+    }
+  },
+  async run({ args }) {
+    const canvasPath = await resolveCanvasPath(String(args.file));
+    if (!canvasPath) {
+      return;
+    }
+    const slug = creativeSlugFromCanvasPath(canvasPath);
+    if (!slug) return;
+    let canvas;
+    let sourceSha;
+    try {
+      const prepared = await prepareCanvas(canvasPath, { write: false });
+      canvas = prepared.fileGraph;
+      sourceSha = prepared.sourceSha;
+    } catch {
+      return;
+    }
+    const title = args.title ? await readDefinitionTitle(canvasPath) : void 0;
+    await syncCreativeDefinitionBestEffort({
+      slug,
+      canvas,
+      sourceSha,
+      ...title ? { title } : {},
+      ...await readDefinitionSourceFields(canvasPath),
+      ...await readDefinitionStrategyFields(canvasPath),
+      ...await readDefinitionSeriesPlace(canvasPath),
+      ...await readDefinitionPlatforms(canvasPath),
+      ...await readDefinitionBody(canvasPath)
+    });
+  }
+});
+
+export {
+  buildDefinitionSyncPayload,
+  readDefinitionSourceFields,
+  readDefinitionPlatforms,
+  readDefinitionBody,
+  readDefinitionTitle,
+  readDefinitionStrategyFields,
+  readDefinitionSeriesPlace,
+  syncCreativeDefinitionBestEffort,
+  resolveCanvasPath,
+  syncDefinitionCommand
+};
+//# sourceMappingURL=chunk-LNRPOULW.js.map