@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.481.0-dev.2d33e194f

package/dist/chunk-W6ASM6UP.js

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

package/dist/chunk-W7KB3LJE.js

@@ -0,0 +1,60 @@
+import {
+  REF_PREFIX
+} from "./chunk-O4ABJ352.js";
+
+// src/commands/canvas/node-preview.ts
+var MAX_PARAMS_PREVIEW_LENGTH = 4e3;
+var SPEC_KEYS = [
+  "model",
+  "aspect_ratio",
+  "image_size",
+  "resolution",
+  "duration",
+  "subject_type",
+  "font_size",
+  "expect",
+  "source",
+  "path",
+  "url"
+];
+var BODY_KEYS = ["prompt", "text", "subject_description"];
+function scalarField(params, key) {
+  const value = params[key];
+  if (typeof value === "number") return String(value);
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed && !trimmed.startsWith(REF_PREFIX) ? trimmed : void 0;
+}
+function compactJson(params) {
+  try {
+    const json = JSON.stringify(params);
+    return json && json !== "{}" ? json : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cap(text) {
+  return text.length > MAX_PARAMS_PREVIEW_LENGTH ? `${text.slice(0, MAX_PARAMS_PREVIEW_LENGTH - 1)}\u2026` : text;
+}
+function nodeParamsPreview(params, deps) {
+  const refsLine = deps && deps.length > 0 ? `refs: ${deps.join(", ")}` : void 0;
+  if (!params || typeof params !== "object") return refsLine;
+  const record = params;
+  const spec = [];
+  for (const key of SPEC_KEYS) {
+    const value = scalarField(record, key);
+    if (value !== void 0) spec.push(`${key}: ${value}`);
+  }
+  if (refsLine) spec.push(refsLine);
+  const body = BODY_KEYS.map((key) => scalarField(record, key)).find(Boolean);
+  const header = spec.join("\n");
+  const composed = header && body ? `${header}
+
+${body}` : header || body || compactJson(record);
+  return composed ? cap(composed) : void 0;
+}
+
+export {
+  nodeParamsPreview
+};
+//# sourceMappingURL=chunk-W7KB3LJE.js.map

package/dist/chunk-WESRVXFS.js

@@ -0,0 +1,133 @@
+import {
+  IDEA_ANGLES,
+  IDEA_FORMATS,
+  checkIdeas,
+  coverageOf,
+  readCreativeRecords,
+  readIdeas,
+  readInsights,
+  readKnowledgeCorpus,
+  readPersonaIds,
+  sameMessageRead,
+  workspaceIdeasJudge
+} from "./chunk-ZLU5QDLU.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-65BQAJMH.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4DM6OAQ6.js";
+
+// src/commands/creatives/ideas.ts
+import { defineCommand } from "citty";
+var BUILD_NEXT = 3;
+var DESCRIPTION = `Check and rank the ad ideas in src/creatives/_ideas/: is each backed by something a customer said (src/content/insights/), does it claim only what the Knowledge holds, is it a different ad from the others, does it fill a gap the live ads leave. Free and local.
+
+Start here, after writing 4-8 idea files (one per file, eight fields: who, message, evidence, awareness, angle, format, job, why):
+  baker creatives ideas            # ranked, with problems; build_next names the ones to make
+  baker creatives make <idea>      # then build each one in build_next
+An idea with a problem is not built until it is fixed. An idea with no evidence is an explore bet: it may be built, and says so.`;
+var ARGS = {
+  full: {
+    type: "boolean",
+    description: "Every idea with its warnings and gaps, and the allowed angle and format values",
+    required: false,
+    default: false
+  }
+};
+registerSchema({ command: "creatives.ideas", description: DESCRIPTION, args: ARGS });
+function ideasHints(report) {
+  const hints = [];
+  const toBuild = report.ideas.filter((i) => i.status === "idea");
+  if (toBuild.length === 0 && report.unreadable.length === 0) {
+    hints.push(
+      "No ideas yet. Write 4-8 files in src/creatives/_ideas/<idea>.md (who, message, evidence, awareness, angle, format, job, why), then run this again."
+    );
+  }
+  if (report.unreadable.length > 0) {
+    hints.push(`Fix ${report.unreadable.map((u) => u.id).join(", ")}: each names what is missing or unknown.`);
+  }
+  const blocked = toBuild.filter((i) => i.problems.length > 0);
+  if (blocked.length > 0) hints.push(`Fix before building: ${blocked.map((i) => i.id).join(", ")}.`);
+  if (report.observedCount < 3) {
+    hints.push(
+      "Few customer quotes on file: run `baker research customers` so ideas stand on what customers said; until then they are explore bets."
+    );
+  } else if (toBuild.length > 0 && toBuild.every((i) => i.evidence === "explore")) {
+    hints.push("No idea cites an insight: put the insight ids that back each one in its `evidence`.");
+  }
+  const next = buildNext(report.ideas);
+  if (next.length === 1) hints.push(`Build: \`baker creatives make ${next[0]}\`.`);
+  if (next.length > 1)
+    hints.push(
+      `Build ${next.join(", ")} at once: one \`creative-producer\` per idea, all spawned in one message in the background, each given its idea id, and handle each as it returns. Never build them one after another: each render takes minutes. Edited an idea after this check? Run \`baker creatives ideas\` again first: a producer cannot build an idea with a problem.`
+    );
+  return hints;
+}
+function buildNext(ideas, count = BUILD_NEXT) {
+  const ready = ideas.filter((i) => i.status === "idea" && i.problems.length === 0);
+  const firstBet = ready.find((i) => i.evidence === "explore");
+  return ready.filter((i) => i.evidence !== "explore" || i === firstBet).slice(0, count).map((i) => i.id);
+}
+function compactIdea(check) {
+  return {
+    idea: check.id,
+    status: check.status,
+    evidence: check.evidence,
+    ...check.quote ? { quote: check.quote.length > 120 ? `${check.quote.slice(0, 117)}...` : check.quote } : {},
+    awareness: check.awareness,
+    angle: check.angle,
+    format: check.format,
+    ...check.problems.length > 0 ? { problems: check.problems } : {},
+    ...check.warnings.length > 0 ? { warnings: check.warnings } : {}
+  };
+}
+async function ideasReport(root, opts = {}) {
+  const judge = opts.ask ? { ask: opts.ask, done: () => Promise.resolve() } : workspaceIdeasJudge(root);
+  const [{ ideas, unreadable }, insights, knowledge, personas, creatives] = await Promise.all([
+    readIdeas(root),
+    readInsights(root, { ask: judge.ask }),
+    readKnowledgeCorpus(root),
+    readPersonaIds(root),
+    readCreativeRecords(root)
+  ]);
+  const sameMessage = await sameMessageRead(ideas, judge.ask);
+  await judge.done();
+  const checked = checkIdeas({ ideas, insights, knowledge, personas, sameMessage, ...coverageOf(ideas, creatives) });
+  return {
+    ideas: checked,
+    unreadable,
+    insightCount: insights.length,
+    observedCount: insights.filter((i) => i.status === "observed").length
+  };
+}
+var ideasCommand = defineCommand({
+  meta: { name: "ideas", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const report = await ideasReport(root);
+    const full = args.full === true;
+    writeJson({
+      ok: true,
+      data: {
+        build_next: buildNext(report.ideas),
+        ideas: full ? report.ideas : report.ideas.map(compactIdea),
+        ...report.unreadable.length > 0 ? { unreadable: report.unreadable } : {},
+        customer_quotes: { total: report.insightCount, observed: report.observedCount },
+        ...full ? { allowed: { angle: IDEA_ANGLES, format: IDEA_FORMATS } } : {}
+      },
+      hints: ideasHints(report)
+    });
+  }
+});
+
+export {
+  ideasHints,
+  buildNext,
+  compactIdea,
+  ideasReport,
+  ideasCommand
+};
+//# sourceMappingURL=chunk-WESRVXFS.js.map

package/dist/chunk-WILN7TD6.js

@@ -0,0 +1,84 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-KB5XJHQX.js";
+
+// src/commands/videos/api.ts
+import { readFile } from "fs/promises";
+import { basename, extname } from "path";
+var videoProcessingTimeoutMs = 18e4;
+var videoReadyPollIntervalMs = 3e3;
+var mimeMap = {
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".avi": "video/x-msvideo",
+  ".mkv": "video/x-matroska"
+};
+var defaultVideoApiDeps = {
+  readFile,
+  post: apiPost,
+  get: apiGet,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  putFile: async (url, contentType, body) => {
+    const response = await fetch(url, { method: "PUT", headers: { "Content-Type": contentType }, body });
+    if (!response.ok) {
+      throw new ApiError("INTERNAL_ERROR", `Mux upload failed: HTTP ${response.status} ${response.statusText}`);
+    }
+  }
+};
+function isVideoFile(filePath) {
+  return mimeMap[extname(filePath).toLowerCase()] !== void 0;
+}
+function detectVideoContentType(filePath, opts = {}) {
+  const ext = extname(filePath).toLowerCase();
+  const contentType = mimeMap[ext];
+  if (!contentType || opts.allowedContentTypes && !opts.allowedContentTypes.includes(contentType)) {
+    throw new ApiError(
+      "VALIDATION_ERROR",
+      opts.unsupportedMessage ?? `Cannot detect content type for extension "${ext}". Use --content-type.`
+    );
+  }
+  return contentType;
+}
+async function uploadLocalVideo(args, deps = defaultVideoApiDeps) {
+  const { uploadUrl, videoId } = await deps.post("/api/videos/upload", {
+    originalFilename: basename(args.file),
+    descriptionContext: args.descriptionContext
+  });
+  await deps.putFile(uploadUrl, args.contentType, await deps.readFile(args.file));
+  return { videoId };
+}
+var PLAYABLE_STATUSES = /* @__PURE__ */ new Set(["uploaded", "processing", "ready"]);
+async function waitForPlayableVideo(deps, videoId, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? videoProcessingTimeoutMs;
+  const pollIntervalMs = opts.pollIntervalMs ?? videoReadyPollIntervalMs;
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "unknown";
+  while (Date.now() <= deadline) {
+    const video = await deps.get("/api/videos/get", { id: videoId });
+    lastStatus = video.status;
+    if (video.muxPlaybackId && PLAYABLE_STATUSES.has(video.status)) {
+      return video;
+    }
+    if (video.status === "error") {
+      throw new ApiError(
+        "INTERNAL_ERROR",
+        "The video library could not process this file. Export it again as an MP4 (H.264) and retry."
+      );
+    }
+    await deps.sleep(pollIntervalMs);
+  }
+  throw new ApiError("TIMEOUT", `Video was not playable before timeout; last status: ${lastStatus}`);
+}
+
+export {
+  videoProcessingTimeoutMs,
+  defaultVideoApiDeps,
+  isVideoFile,
+  detectVideoContentType,
+  uploadLocalVideo,
+  waitForPlayableVideo
+};
+//# sourceMappingURL=chunk-WILN7TD6.js.map