@koda-sl/baker-cli 0.453.0-dev.faf35eacb → 0.454.0-dev.67ad219ab

package/dist/chunk-TIL76IDK.js

@@ -0,0 +1,136 @@
+import {
+  coercePathUrlToUrl,
+  looksLikeHttpUrl
+} from "./chunk-S2IOUC5B.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-TIL76IDK.js.map

package/dist/chunk-TQO6WNUH.js

@@ -0,0 +1,166 @@
+import {
+  HEADLINE_SET_FLOOR,
+  SAME_CLAIM_HELD,
+  TELL_QUESTIONS,
+  copySentences,
+  sameClaimQuestion,
+  tellQuestionsFor
+} from "./chunk-4NZ47VXO.js";
+import {
+  rememberedJev
+} from "./chunk-XDEQ3JIR.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-RNHSGH44.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-TIL76IDK.js";
+import {
+  CAPABILITY_SURFACE_SPECS
+} from "./chunk-ZJWUBJYQ.js";
+
+// src/commands/ads/boolean-word-positional.ts
+var BOOLEAN_WORD = /^(true|false)$/i;
+function booleanWordPositionalError(args, entity) {
+  const positionals = Array.isArray(args._) ? args._ : [];
+  const word = positionals.find((value2) => typeof value2 === "string" && BOOLEAN_WORD.test(value2));
+  if (word === void 0) {
+    return void 0;
+  }
+  const value = word.toLowerCase();
+  const raised = Object.keys(args).filter((key) => key !== "_" && args[key] === true);
+  const named = raised.length > 0 ? raised.map((flag) => `--${flag}`).join(" or ") : "a boolean flag";
+  const fix = raised.length > 0 ? raised.map((flag) => `--${flag}=${value}`).join(" or ") : `--<flag>=${value}`;
+  const negated = raised.length === 1 && value === "false" ? ` (or --no-${raised[0]})` : "";
+  return `"${word}" was read as the ${entity} target, not as a value for ${named}. A boolean flag written with a space is set to TRUE and the word is dropped \u2014 attach it instead: ${fix}${negated}.`;
+}
+
+// src/commands/capabilities/fix.ts
+function capabilityFix(surface) {
+  const spec = CAPABILITY_SURFACE_SPECS[surface];
+  return {
+    action: `baker capabilities ${surface}`,
+    explanation: `Do not guess another field name. \`baker capabilities ${surface}\` lists every ${spec.label} change with its required and optional fields and the exact values each field accepts, plus what cannot be changed here at all and why. Read it, then either re-stage correctly or tell the user this part is out of reach \u2014 and carry on with the rest of the job either way.`
+  };
+}
+
+// src/commands/ads/copy-hints.ts
+import path from "path";
+
+// src/engine/copy-tells/judge.ts
+var SAMPLE_MAX = 60;
+var sample = (text) => text.length <= SAMPLE_MAX ? text : `${text.slice(0, SAMPLE_MAX)}\u2026`;
+async function judgedCopyTells(input, ask) {
+  const sentences = input.texts.flatMap((t) => copySentences(t));
+  const pairs = (input.headlineSets ?? []).map((set) => set.map((h) => h.trim()).filter(Boolean)).filter((set) => set.length >= HEADLINE_SET_FLOOR).flatMap((set, s) => set.flatMap((a, i) => set.slice(i + 1).map((b) => ({ set: s, a, b }))));
+  const questions = [...sentences.flatMap(tellQuestionsFor), ...pairs.map(({ a, b }) => sameClaimQuestion(a, b))];
+  if (questions.length === 0) return [];
+  const answers = await ask(questions);
+  if (answers === null) return null;
+  const tells = [];
+  TELL_QUESTIONS.forEach((tell, t) => {
+    const hits = sentences.filter((_, s) => (answers[s * TELL_QUESTIONS.length + t] ?? 0) >= tell.threshold);
+    if (hits.length > 0) tells.push({ id: tell.id, count: hits.length, sample: sample(hits[0]?.text ?? "") });
+  });
+  const offset = sentences.length * TELL_QUESTIONS.length;
+  const cycled = pairs.filter((_, p) => (answers[offset + p] ?? 0) >= SAME_CLAIM_HELD);
+  for (const set of new Set(cycled.map((p) => p.set))) {
+    const inSet = cycled.filter((p) => p.set === set);
+    const { a, b } = inSet[0] ?? { a: "", b: "" };
+    tells.push({ id: "synonym-cycling", count: inSet.length, sample: sample(`"${a}" / "${b}"`) });
+  }
+  return tells;
+}
+
+// src/commands/ads/copy-hints.ts
+var COPY_KEYS = /* @__PURE__ */ new Set([
+  "headline",
+  "headlines",
+  "longheadline",
+  "longheadlines",
+  "shortheadline",
+  "shortheadlines",
+  "description",
+  "descriptions",
+  "primarytext",
+  "primarytexts",
+  "message",
+  "messages",
+  "commentary",
+  "body",
+  "bodies",
+  "text",
+  "calltoaction",
+  "linkdescription",
+  "sitelinktext",
+  "callout",
+  "callouts",
+  "introtext"
+]);
+var HEADLINE_SET_KEYS = /* @__PURE__ */ new Set(["headlines", "longheadlines", "shortheadlines"]);
+var MAX_HINTS = 5;
+var SYNONYM_PAIR_FLOOR = 2;
+function asStrings(value) {
+  const one = (v) => {
+    const text = typeof v === "string" ? v : v !== null && typeof v === "object" ? v.text : "";
+    return typeof text === "string" && text.trim() ? text : void 0;
+  };
+  const values = Array.isArray(value) ? value : [value];
+  return values.map(one).filter((v) => v !== void 0);
+}
+function collectCopy(value, depth = 0) {
+  const texts = [];
+  const headlineSets = [];
+  if (depth > 4 || value === null || typeof value !== "object") return { texts, headlineSets };
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nested = collectCopy(item, depth + 1);
+      texts.push(...nested.texts);
+      headlineSets.push(...nested.headlineSets);
+    }
+    return { texts, headlineSets };
+  }
+  for (const [key, raw] of Object.entries(value)) {
+    const normalized = key.toLowerCase().replace(/[_-]/g, "");
+    const strings = COPY_KEYS.has(normalized) ? asStrings(raw) : [];
+    if (strings.length > 0) {
+      texts.push(...strings);
+      if (HEADLINE_SET_KEYS.has(normalized) && strings.length > 1) headlineSets.push(strings);
+      continue;
+    }
+    const nested = collectCopy(raw, depth + 1);
+    texts.push(...nested.texts);
+    headlineSets.push(...nested.headlineSets);
+  }
+  return { texts, headlineSets };
+}
+function hintFor(tell) {
+  if (tell.id === "synonym-cycling") {
+    return `AI COPY TELL \u2014 ${tell.count} headline pairs are the same claim reworded (${tell.sample}). A cycled set gives the auction nothing to choose between: make each headline a different claim, not a different verb.`;
+  }
+  return `AI COPY TELL (${tell.id}) \u2014 "${tell.sample}". This construction reads as machine-written; rewrite it as a plain, specific claim before publishing.`;
+}
+async function adCopyHints(payload, ask) {
+  const { texts, headlineSets } = collectCopy(payload);
+  if (texts.length === 0) return [];
+  const cacheDir = path.join(findWorkspaceRoot(process.cwd()) ?? process.cwd(), "canvas", ".cache");
+  const spent = [];
+  const judged = await judgedCopyTells(
+    { texts: texts.flatMap((t) => t.split("\n")), headlineSets },
+    ask ?? rememberedJev(path.join(cacheDir, "copy-tells.json"), (u) => spent.push(u))
+  ).catch(() => null);
+  await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+  const cycled = (judged ?? []).filter((t) => t.id === "synonym-cycling" && t.count >= SYNONYM_PAIR_FLOOR).sort((a, b) => b.count - a.count).slice(0, 1);
+  const tells = [...cycled, ...(judged ?? []).filter((t) => t.id !== "synonym-cycling")];
+  tells.sort(
+    (a, b) => (b.id === "synonym-cycling" ? 1 : 0) - (a.id === "synonym-cycling" ? 1 : 0) || b.count - a.count
+  );
+  return tells.slice(0, MAX_HINTS).map(hintFor);
+}
+
+export {
+  booleanWordPositionalError,
+  capabilityFix,
+  adCopyHints
+};
+//# sourceMappingURL=chunk-TQO6WNUH.js.map

package/dist/chunk-UK4DUS6I.js

@@ -0,0 +1,52 @@
+import {
+  commandFor,
+  declaredArg
+} from "./chunk-5WW456MW.js";
+
+// src/cache-flag.ts
+var NO_CACHE_ARG = {
+  type: "boolean",
+  description: "Skip cached results and read live from the platform (slower)",
+  required: false
+};
+var LEGACY = "--skip-cache";
+var CANONICAL = "--no-cache";
+var PARSEABLE = "--noCache";
+function respell(token, from, to) {
+  if (token === from) {
+    return [to];
+  }
+  if (!token.startsWith(`${from}=`)) {
+    return [token];
+  }
+  return token.slice(from.length + 1) === "false" ? [] : [to];
+}
+function normalizeCacheFlag(argv) {
+  return rewriteBeforeDoubleDash(argv, (token) => respell(token, LEGACY, CANONICAL));
+}
+function cacheFlagForCommand(root, argv) {
+  if (!argv.includes(CANONICAL)) {
+    return argv;
+  }
+  const command = commandFor(root, argv);
+  if (!command || declaredArg(command, "no-cache")) {
+    return argv;
+  }
+  return rewriteBeforeDoubleDash(argv, (token) => token === CANONICAL ? [] : [token]);
+}
+function cacheFlagForParser(argv) {
+  return rewriteBeforeDoubleDash(argv, (token) => respell(token, CANONICAL, PARSEABLE));
+}
+function rewriteBeforeDoubleDash(argv, rewrite) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  return argv.flatMap((token, index) => index >= limit ? [token] : rewrite(token));
+}
+
+export {
+  NO_CACHE_ARG,
+  normalizeCacheFlag,
+  cacheFlagForCommand,
+  cacheFlagForParser
+};
+//# sourceMappingURL=chunk-UK4DUS6I.js.map

package/dist/chunk-UK4DUS6I.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cache-flag.ts"],"sourcesContent":["/**\n * One way to ask for a fresh read.\n *\n * Cached reads used to be bypassed by two different flags: `--no-cache` on the\n * Google, GA4, GSC, research and X families, `--skip-cache` on LinkedIn and\n * Meta. They named the two cache layers — `--no-cache` the CLI's own disk cache,\n * `--skip-cache` the server's — which is a distinction no caller has ever wanted\n * to make: a caller asking for fresh data wants fresh data, and the layer that\n * would have answered instead is an implementation detail of ours.\n *\n * The split was not survivable once an unrecognised flag started failing the\n * call instead of being dropped. The reports runtime appends `--no-cache` for\n * `?fresh=true` and cannot know which family a report reads, so every report row\n * backed by `ads linkedin analytics` or `ads meta insights` failed on refresh —\n * silently, as an empty row. So `--no-cache` is the name, on every command that\n * caches anything, and it bypasses both layers.\n */\n\nimport { declaredArg } from \"./output-flag.ts\";\nimport { commandFor, type IntrospectableCommand } from \"./unknown-flags.ts\";\n\n/**\n * The declaration LinkedIn and Meta share, so `baker schema` reads the same on\n * every command in the families this rename covers. The older families still\n * carry their own wording for the same flag.\n */\nexport const NO_CACHE_ARG = {\n  type: \"boolean\",\n  description: \"Skip cached results and read live from the platform (slower)\",\n  required: false,\n} as const;\n\nconst LEGACY = \"--skip-cache\";\nconst CANONICAL = \"--no-cache\";\n/**\n * The spelling handed to the parser, and the reason this module exists twice\n * over. citty resolves a bare `--no-cache` to `cache: false` rather than filling\n * the `no-cache` arg the command declared, so every `args[\"no-cache\"]` read in\n * the CLI sees `undefined` and the flag does nothing at all — the same trap\n * `wantsAsync` in `ads/meta/insights.ts` records for `--no-async`. citty\n * registers `camelCase(name)` as an alias of every declared arg, and mri leaves\n * `--noCache` alone, so this spelling lands in `args[\"no-cache\"]` as intended.\n */\nconst PARSEABLE = \"--noCache\";\n\n/**\n * One token, respelled — and collapsed to the bare flag when it carried a value.\n *\n * `--no-cache=true` is not the same option with a value: mri's `--no-` branch\n * never splits on `=`, so the whole `cache=true` becomes the key and the flag is\n * dropped without a word. The bare flag says the same thing and survives, and\n * the one value mri read as off drops the flag rather than mis-stating it.\n */\nfunction respell(token: string, from: string, to: string): string[] {\n  if (token === from) {\n    return [to];\n  }\n  if (!token.startsWith(`${from}=`)) {\n    return [token];\n  }\n  return token.slice(from.length + 1) === \"false\" ? [] : [to];\n}\n\n/**\n * The legacy spelling, translated before anything parses it.\n *\n * Sandboxes already running carry the old tool docs until their next sync, and\n * an agent that reads `--skip-cache` there would now have its call refused —\n * turning a rename into exactly the failure the rename exists to fix. Kept for\n * one release; the guard in `cache-flag-coverage.test.ts` is what stops the\n * second spelling coming back into the commands themselves.\n */\nexport function normalizeCacheFlag(argv: string[]): string[] {\n  return rewriteBeforeDoubleDash(argv, (token) => respell(token, LEGACY, CANONICAL));\n}\n\n/**\n * `--no-cache` dropped where the command it addresses caches nothing.\n *\n * The reports runtime appends it to every read on `?fresh=true` and cannot know\n * which commands cache, so a report reading `winning-ads winners` failed on\n * every Refresh with \"not an option\" — and the same report answered fine\n * without it. A command with no cache already reads fresh, which is all the\n * flag asks for. Applied before `refuseUnknownFlags`, like `--output json`.\n */\nexport function cacheFlagForCommand(root: IntrospectableCommand, argv: string[]): string[] {\n  if (!argv.includes(CANONICAL)) {\n    return argv;\n  }\n  const command = commandFor(root, argv);\n  if (!command || declaredArg(command, \"no-cache\")) {\n    return argv;\n  }\n  return rewriteBeforeDoubleDash(argv, (token) => (token === CANONICAL ? [] : [token]));\n}\n\n/**\n * The canonical spelling in the form citty can actually parse.\n *\n * Deliberately applied after `refuseUnknownFlags`, not with the rewrite above:\n * that guard quotes the token back to the caller, and a command that does not\n * take this flag should be refused in the spelling the caller typed.\n */\nexport function cacheFlagForParser(argv: string[]): string[] {\n  return rewriteBeforeDoubleDash(argv, (token) => respell(token, CANONICAL, PARSEABLE));\n}\n\n/**\n * Everything after `--` is the caller's own payload, not ours to rewrite — the\n * same boundary `unknown-flags.ts` refuses to read past.\n */\nfunction rewriteBeforeDoubleDash(argv: string[], rewrite: (token: string) => string[]): string[] {\n  const end = argv.indexOf(\"--\");\n  const limit = end === -1 ? argv.length : end;\n  return argv.flatMap((token, index) => (index >= limit ? [token] : rewrite(token)));\n}\n"],"mappings":";;;;;;AA0BO,IAAM,eAAe;AAAA,EAC1B,MAAM;AAAA,EACN,aAAa;AAAA,EACb,UAAU;AACZ;AAEA,IAAM,SAAS;AACf,IAAM,YAAY;AAUlB,IAAM,YAAY;AAUlB,SAAS,QAAQ,OAAe,MAAc,IAAsB;AAClE,MAAI,UAAU,MAAM;AAClB,WAAO,CAAC,EAAE;AAAA,EACZ;AACA,MAAI,CAAC,MAAM,WAAW,GAAG,IAAI,GAAG,GAAG;AACjC,WAAO,CAAC,KAAK;AAAA,EACf;AACA,SAAO,MAAM,MAAM,KAAK,SAAS,CAAC,MAAM,UAAU,CAAC,IAAI,CAAC,EAAE;AAC5D;AAWO,SAAS,mBAAmB,MAA0B;AAC3D,SAAO,wBAAwB,MAAM,CAAC,UAAU,QAAQ,OAAO,QAAQ,SAAS,CAAC;AACnF;AAWO,SAAS,oBAAoB,MAA6B,MAA0B;AACzF,MAAI,CAAC,KAAK,SAAS,SAAS,GAAG;AAC7B,WAAO;AAAA,EACT;AACA,QAAM,UAAU,WAAW,MAAM,IAAI;AACrC,MAAI,CAAC,WAAW,YAAY,SAAS,UAAU,GAAG;AAChD,WAAO;AAAA,EACT;AACA,SAAO,wBAAwB,MAAM,CAAC,UAAW,UAAU,YAAY,CAAC,IAAI,CAAC,KAAK,CAAE;AACtF;AASO,SAAS,mBAAmB,MAA0B;AAC3D,SAAO,wBAAwB,MAAM,CAAC,UAAU,QAAQ,OAAO,WAAW,SAAS,CAAC;AACtF;AAMA,SAAS,wBAAwB,MAAgB,SAAgD;AAC/F,QAAM,MAAM,KAAK,QAAQ,IAAI;AAC7B,QAAM,QAAQ,QAAQ,KAAK,KAAK,SAAS;AACzC,SAAO,KAAK,QAAQ,CAAC,OAAO,UAAW,SAAS,QAAQ,CAAC,KAAK,IAAI,QAAQ,KAAK,CAAE;AACnF;","names":[]}