@koda-sl/baker-cli 0.510.0 → 0.511.0-dev.2d26314a2

package/dist/chunk-DPFHGPIW.js

@@ -0,0 +1,122 @@
+import {
+  prepareCanvas,
+  unsuppliedPlaceholderAssets
+} from "./chunk-3I2B5U2N.js";
+import {
+  isSourceStale
+} from "./chunk-4CNR3MNJ.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-DPFHGPIW.js.map

package/dist/chunk-DSJHEMXL.js

@@ -0,0 +1,197 @@
+import {
+  mediaTagsCreateRequestSchema,
+  mediaTagsDeleteRequestSchema,
+  mediaTagsUpdateRequestSchema
+} from "./chunk-4CNR3MNJ.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-Q7US4OOA.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-DSJHEMXL.js.map

package/dist/chunk-DUCUOZLS.js

@@ -0,0 +1,225 @@
+import {
+  BRAND_DIR,
+  inkLuma,
+  logoArtwork
+} from "./chunk-AULSX5ZA.js";
+import {
+  fetchExternalBytes
+} from "./chunk-PONLPYD7.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+
+// src/commands/canvas/clientLogo.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import * as cheerio from "cheerio";
+import path from "path";
+function decideClientLogo(domain, lookup) {
+  if (!domain) return { use: false, reason: "no_domain" };
+  const verdict = lookup?.brandMatch?.verdict;
+  if (verdict === "mismatch") {
+    return { use: false, reason: "mismatch", ...lookup?.brandMatch?.name ? { wrongBrand: lookup.brandMatch.name } : {} };
+  }
+  if (verdict !== "confirmed") return { use: false, reason: "unverified" };
+  const url = lookup?.hits?.map((hit) => hit.imageUrl ?? hit.sourceUrl).find((candidate) => Boolean(candidate));
+  return url ? { use: true, url } : { use: false, reason: "no_hits" };
+}
+function clientLogoMissNote(decision, domain) {
+  switch (decision.reason) {
+    case "no_domain":
+      return "Baker has no website on record for this company, so their mark could not be looked up.";
+    case "mismatch":
+      return `The mark found for \`${domain}\` belongs to ${decision.wrongBrand ?? "a different company"}, not to this client, so it was not used.`;
+    default:
+      return `No brand mark could be confirmed for \`${domain}\`, so nothing was placed.`;
+  }
+}
+function hostOf(site) {
+  try {
+    return new URL(/^https?:\/\//i.test(site) ? site : `https://${site}`).hostname.replace(/^www\./i, "").toLowerCase();
+  } catch {
+    return null;
+  }
+}
+var NOT_THE_LOGO = /favicon|apple-touch|sprite|(?:^|[/_.-])icons?(?:[/_.-]|$)|client|customer|partner|testimonial|trust|badge|award/i;
+function sayings(hit, url) {
+  const meta = hit.providerMeta ?? {};
+  const given = ["alt", "class", "id", "title"].map((key) => typeof meta[key] === "string" ? meta[key] : "");
+  return [new URL(url).pathname, hit.name ?? "", hit.description ?? "", ...given].join(" ");
+}
+function logoFromExtract(hits, domain) {
+  const own = hostOf(domain);
+  if (!own) return null;
+  const candidates = hits.flatMap((hit) => {
+    const url = hit.url ?? hit.imageUrl ?? hit.sourceUrl;
+    const host = url ? hostOf(url) : null;
+    if (!url || !host || host !== own && !host.endsWith(`.${own}`)) return [];
+    const said = sayings(hit, url);
+    if (!/logo/i.test(said) || NOT_THE_LOGO.test(said)) return [];
+    return [{ url, score: (/\.svg(?:\?|$)/i.test(url) ? 2 : 0) + (/logo/i.test(new URL(url).pathname) ? 1 : 0) }];
+  });
+  candidates.sort((a, b) => b.score - a.score || a.url.length - b.url.length);
+  return candidates[0]?.url ?? null;
+}
+var MAX_INLINE_SVG = 3e5;
+var BRAND_PLACES = "header, nav, [role=banner]";
+var IMAGE_ADDRESS = ["src", "data-src", "data-lazy-src", "data-original"];
+function logoFromPage(html, pageUrl, domain) {
+  const own = hostOf(domain);
+  if (!own) return null;
+  const $ = cheerio.load(html);
+  for (const el of $(`${BRAND_PLACES}`).find("img, svg").toArray()) {
+    const node = $(el);
+    const said = [node, node.closest("a")].flatMap((n) => ["class", "id", "alt", "aria-label", "title"].map((k) => n.attr(k) ?? "")).join(" ");
+    if (!/logo/i.test(said) || NOT_THE_LOGO.test(said)) continue;
+    if (el.tagName === "svg") {
+      const svg = standaloneSvg($, node);
+      if (svg) return { kind: "svg", svg };
+      continue;
+    }
+    const url = IMAGE_ADDRESS.map((k) => node.attr(k)?.trim() ?? "").filter((a) => a !== "" && !a.startsWith("data:")).map((a) => absolute(a, pageUrl)).find((a) => a !== null);
+    const host = url ? hostOf(url) : null;
+    if (url && host && (host === own || host.endsWith(`.${own}`))) return { kind: "url", url };
+  }
+  return null;
+}
+function absolute(address, base) {
+  try {
+    const url = new URL(address, base);
+    return /^https?:$/.test(url.protocol) ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+function standaloneSvg($, node) {
+  const draws = node.find("path, circle, rect, polygon, polyline, ellipse, line, text").length > 0;
+  if (!draws || node.find("use").length > 0) return null;
+  const copy = node.clone();
+  if (!copy.attr("xmlns")) copy.attr("xmlns", "http://www.w3.org/2000/svg");
+  const svg = $.html(copy);
+  return svg.length <= MAX_INLINE_SVG ? svg : null;
+}
+function logoTone(inkLuma2) {
+  return inkLuma2 !== null && inkLuma2 > 170 ? "dark" : "light";
+}
+function withLogoRegistered(tokensJson, logo) {
+  if (tokensJson === null) return null;
+  let tokens;
+  try {
+    tokens = JSON.parse(tokensJson);
+  } catch {
+    return null;
+  }
+  if (!tokens || typeof tokens !== "object" || Array.isArray(tokens)) return null;
+  const doc = tokens;
+  const logos = Array.isArray(doc.logos) ? doc.logos : [];
+  if (logos.some((l) => l?.path === logo.path)) return null;
+  const next = { ...doc, logos: [...logos, { variant: "logo", background: logo.background, path: logo.path }] };
+  return `${JSON.stringify(next, null, 2)}
+`;
+}
+function logoMissingHint(company, domain) {
+  return `No logo on file for ${company}: add it on the Brand page${domain ? ` (we could not find it on ${domain})` : ""}.`;
+}
+function extensionOf(url) {
+  return /\.(svg|png|jpg|jpeg|webp)(?:\?|$)/i.exec(url)?.[1]?.toLowerCase() ?? "svg";
+}
+var MAX_LOGO_BYTES = 3e6;
+async function downloaded(url) {
+  try {
+    const { buffer } = await fetchExternalBytes(url, { maxBytes: MAX_LOGO_BYTES });
+    return buffer.byteLength > 0 ? { bytes: buffer, extension: extensionOf(url) } : null;
+  } catch {
+    return null;
+  }
+}
+async function logoOnSite(domain) {
+  const host = hostOf(domain);
+  if (!host) return null;
+  const page = `https://${host}/`;
+  try {
+    const { buffer } = await fetchExternalBytes(page, { maxBytes: MAX_LOGO_BYTES });
+    const found = logoFromPage(buffer.toString("utf8"), page, domain);
+    if (found?.kind === "svg") return { bytes: Buffer.from(found.svg, "utf8"), extension: "svg" };
+    const file = found ? await downloaded(found.url) : null;
+    if (file) return file;
+  } catch {
+  }
+  try {
+    const listed = await apiPost("/api/images/extract", { url: page, limit: 50 });
+    const url = logoFromExtract(listed.hits ?? [], domain);
+    return url ? await downloaded(url) : null;
+  } catch {
+    return null;
+  }
+}
+async function logoSource(domain) {
+  let lookup = null;
+  if (domain) {
+    try {
+      lookup = await apiPost("/api/images/logo", { domain, variant: "logo", autoIngest: 1 });
+    } catch {
+      lookup = null;
+    }
+  }
+  const decision = decideClientLogo(domain, lookup);
+  if (decision.use) {
+    const file = await downloaded(decision.url);
+    if (file) return file;
+  }
+  if (domain && !(decision.use === false && decision.reason === "mismatch")) {
+    const file = await logoOnSite(domain);
+    if (file) return file;
+  }
+  return { note: clientLogoMissNote(decision.use ? { use: false, reason: "no_hits" } : decision, domain) };
+}
+async function inkOf(bytes) {
+  try {
+    return inkLuma((await logoArtwork(bytes)).data);
+  } catch {
+    return null;
+  }
+}
+async function fetchClientLogo(root = ".") {
+  let domain;
+  let company;
+  try {
+    const found = await apiGet("/api/company");
+    domain = found.data.domain?.trim() || void 0;
+    company = found.data.name;
+  } catch {
+    domain = void 0;
+  }
+  const named = { ...domain ? { domain } : {}, ...company ? { company } : {} };
+  const source = await logoSource(domain);
+  if ("note" in source) return { ok: false, reason: source.note, ...named };
+  try {
+    const tone = logoTone(await inkOf(source.bytes));
+    const dir = path.join(root, BRAND_DIR, "logos");
+    await mkdir(dir, { recursive: true });
+    const file = path.join(dir, `logo-${tone}.${source.extension}`);
+    await writeFile(file, source.bytes);
+    await registerLogo(root, path.join(BRAND_DIR, "logos", path.basename(file)), tone);
+    return { ok: true, path: file, ...named };
+  } catch {
+    return { ok: false, reason: clientLogoMissNote({ use: false, reason: "no_hits" }, domain), ...named };
+  }
+}
+async function registerLogo(root, relative, background) {
+  const tokensPath = path.join(root, BRAND_DIR, "tokens.json");
+  const next = withLogoRegistered(await readFile(tokensPath, "utf8").catch(() => null), { path: relative, background });
+  if (next !== null) await writeFile(tokensPath, next, "utf8").catch(() => void 0);
+}
+async function withClientLogo(root, kit, reread, fetch = fetchClientLogo) {
+  if (kit.logo) return { kit };
+  const fetched = await fetch(root).catch(() => null);
+  if (fetched?.ok) return { kit: await reread() };
+  return { kit, hint: logoMissingHint(fetched?.company ?? "your company", fetched?.domain) };
+}
+
+export {
+  fetchClientLogo,
+  withClientLogo
+};
+//# sourceMappingURL=chunk-DUCUOZLS.js.map