@koda-sl/baker-cli 0.478.0 → 0.479.0

package/dist/use-6ULEM3WE.js

@@ -0,0 +1,95 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-XDZVBX6L.js";
+import "./chunk-N5O67GK5.js";
+import "./chunk-EE72SSB2.js";
+import {
+  registerSchema,
+  writeJson,
+  writeOutput
+} from "./chunk-WNSE7N75.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/use.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.use",
+  description: "Ingest a URL and wait for the library record to be ready.",
+  args: {
+    url: { type: "string", description: "Image URL", required: true },
+    source: { type: "string", description: "Image source enum", required: false, default: "uploaded" },
+    "max-wait": { type: "number", description: "Max wait ms", required: false, default: 3e4 },
+    context: {
+      type: "string",
+      description: "Free-text hint passed to Gemini describe to bias the generated description and tags",
+      required: false
+    },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  }
+});
+var POLL_INTERVAL_MS = 1500;
+function emitReady(ingestResult, doc, args) {
+  const format = typeof args.output === "string" && args.output.length > 0 ? args.output : "json";
+  const fields = typeof args.fields === "string" && args.fields.length > 0 ? args.fields.split(",") : void 0;
+  writeOutput(
+    { ok: true, data: format === "json" ? { ...ingestResult, image: doc } : doc },
+    format,
+    fields,
+    args.full === true
+  );
+}
+var useCommand = defineCommand({
+  meta: {
+    name: "use",
+    description: "Sugar over `ingest`: download \u2192 store \u2192 wait until describe + embed complete \u2192 return ready library record.\n\nExample: baker images use https://cdn.example.com/hero.png --source uploaded"
+  },
+  args: {
+    url: { type: "positional", description: "Image URL", required: false },
+    source: { type: "string", description: "Source enum", required: false },
+    "max-wait": { type: "string", description: "Max wait ms (default 30000)", required: false },
+    context: { type: "string", description: "Description context hint", required: false },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const url = args.url;
+      if (!url) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "URL is required" } });
+        process.exit(1);
+      }
+      const source = args.source ?? "uploaded";
+      const maxWait = args["max-wait"] ? Number(args["max-wait"]) : 3e4;
+      const ingestBody = { url, source };
+      if (args.context) ingestBody.descriptionContext = args.context;
+      const ingestResult = await apiPost("/api/images/ingest", ingestBody);
+      const start = Date.now();
+      while (Date.now() - start < maxWait) {
+        const doc = await apiGet("/api/images/get", { id: ingestResult.imageId });
+        if (doc.status === "ready" || doc.status === "error") {
+          emitReady(ingestResult, doc, args);
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+      }
+      writeJson({ ok: false, error: { code: "TIMEOUT", message: `Image not ready within ${maxWait}ms` } });
+      process.exit(1);
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson({ ok: false, error: { code: err.code, message: err.message } });
+        process.exit(1);
+      }
+      writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  useCommand
+};
+//# sourceMappingURL=use-6ULEM3WE.js.map

package/dist/validate-PEWGXGCR.js

@@ -0,0 +1,117 @@
+import {
+  outputRatioWarningsFor,
+  shownBaseline
+} from "./chunk-TF4PGUO5.js";
+import {
+  creativeSlugFromCanvasPath
+} from "./chunk-65PUXMWE.js";
+import "./chunk-KCKC637S.js";
+import {
+  exitOnPrepareError,
+  prepareCanvas
+} from "./chunk-7HJR5M4R.js";
+import "./chunk-BSEB55E6.js";
+import "./chunk-RCSOG2DV.js";
+import "./chunk-LD4CHA7U.js";
+import "./chunk-LCW3U4EA.js";
+import "./chunk-7U3V64YT.js";
+import "./chunk-MMVLRUMK.js";
+import "./chunk-R2TAVQGZ.js";
+import "./chunk-DF22CTXE.js";
+import "./chunk-AS5VL32C.js";
+import "./chunk-FNA277HP.js";
+import "./chunk-5WMTPYKT.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-23H4ZJRP.js";
+import {
+  defaultRegistry,
+  validateCanvasDeep
+} from "./chunk-HJQ7N7FC.js";
+import "./chunk-D4I3KULJ.js";
+import "./chunk-5NS4CNF6.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-6KK26F2T.js";
+import "./chunk-U2452GLO.js";
+import "./chunk-ZBV5IV5T.js";
+import "./chunk-T6ATGN7Y.js";
+import "./chunk-KPYDTIAI.js";
+import "./chunk-KIGGMKAE.js";
+import "./chunk-DWX44QL6.js";
+import "./chunk-2FSEESJU.js";
+import "./chunk-CVBKW75S.js";
+import "./chunk-BLAHHMPF.js";
+import "./chunk-FRK7SSEH.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-XDZVBX6L.js";
+import "./chunk-N5O67GK5.js";
+import {
+  optionalTurnId
+} from "./chunk-EE72SSB2.js";
+import "./chunk-WNSE7N75.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/canvas/validate.ts
+import path from "path";
+import { defineCommand } from "citty";
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate a canvas JSON file (no execution). Brings the canvas up to date with its prompt.json first (prompt.json and, for a video, scenes/*.json edits are written into the canvas, exactly as `run` does), then checks it: a per-node cost preview, each node's deep validators (composition meta checks for hyperframe_render/_snapshot), and each generator prompt measured with its {{slots}} filled against the model's character cap (PROMPT_OVER_MODEL_LIMIT)."
+  },
+  args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
+  async run({ args }) {
+    const filePath = path.resolve(String(args.file));
+    const slug = creativeSlugFromCanvasPath(filePath) ?? void 0;
+    const baseline = slug ? (await shownBaseline({
+      canvasRoot: canvasOutputsRoot(filePath),
+      slug,
+      creativeDir: path.dirname(filePath),
+      turnId: optionalTurnId(),
+      record: false
+    })).baseline : void 0;
+    let prepared;
+    try {
+      prepared = await prepareCanvas(filePath, {
+        gate: true,
+        log: (line) => process.stderr.write(`${line}
+`),
+        ...baseline ? { baseline } : {}
+      });
+    } catch (e) {
+      exitOnPrepareError(e);
+    }
+    const result = await validateCanvasDeep(prepared.canvas, defaultRegistry());
+    if (!result.ok) {
+      process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "validation", issues: result.issues } }, null, 2)}
+`);
+      process.exit(2);
+      return;
+    }
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          total_nodes: result.canvas.nodes.length,
+          estimated_credits: result.estimatedCredits,
+          cost_preview: result.perNodeCredits ?? [],
+          style_projection: prepared.projections.style,
+          scene_projection: prepared.projections.scenes,
+          canvas_updated: prepared.written,
+          normalized_paths: prepared.rewrites,
+          warnings: [...result.warnings ?? [], ...await outputRatioWarningsFor(prepared.canvas, filePath)]
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+export {
+  validateCommand
+};
+//# sourceMappingURL=validate-PEWGXGCR.js.map

package/dist/validate-PEWGXGCR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/validate.ts"],"sourcesContent":["import path from \"node:path\";\nimport { defineCommand } from \"citty\";\nimport { defaultRegistry, validateCanvasDeep } from \"../../engine/index.ts\";\nimport { optionalTurnId } from \"../../env.ts\";\nimport { outputRatioWarningsFor } from \"./output-ratio.ts\";\nimport { canvasOutputsRoot } from \"./normalize-paths.ts\";\nimport { creativeSlugFromCanvasPath } from \"./run-record.ts\";\nimport { shownBaseline } from \"./shown-anchor.ts\";\nimport { exitOnPrepareError, type PreparedCanvas, prepareCanvas } from \"./prepare-canvas.ts\";\n\nexport const validateCommand = defineCommand({\n  meta: {\n    name: \"validate\",\n    description:\n      \"Validate a canvas JSON file (no execution). Brings the canvas up to date with its prompt.json first (prompt.json and, for a video, scenes/*.json edits are written into the canvas, exactly as `run` does), then checks it: a per-node cost preview, each node's deep validators (composition meta checks for hyperframe_render/_snapshot), and each generator prompt measured with its {{slots}} filled against the model's character cap (PROMPT_OVER_MODEL_LIMIT).\",\n  },\n  args: { file: { type: \"positional\", required: true, description: \"Path to canvas JSON\" } },\n  async run({ args }) {\n    const filePath = path.resolve(String(args.file));\n    // The idea the person saw, as a run would hold it: validate is the free proof of that gate (it records nothing).\n    const slug = creativeSlugFromCanvasPath(filePath) ?? undefined;\n    const baseline = slug\n      ? (\n          await shownBaseline({\n            canvasRoot: canvasOutputsRoot(filePath),\n            slug,\n            creativeDir: path.dirname(filePath),\n            turnId: optionalTurnId(),\n            record: false,\n          })\n        ).baseline\n      : undefined;\n    let prepared: PreparedCanvas;\n    try {\n      prepared = await prepareCanvas(filePath, {\n        gate: true,\n        log: (line) => process.stderr.write(`${line}\\n`),\n        ...(baseline ? { baseline } : {}),\n      });\n    } catch (e) {\n      exitOnPrepareError(e);\n    }\n\n    const result = await validateCanvasDeep(prepared.canvas, defaultRegistry());\n    if (!result.ok) {\n      process.stderr.write(`${JSON.stringify({ ok: false, error: { code: \"validation\", issues: result.issues } }, null, 2)}\\n`);\n      process.exit(2);\n      return;\n    }\n\n    // Warnings are advisory: the canvas is valid and runnable, so exit 0. They flag\n    // likely-wrong-but-legal config (a missing element reference, a scene span past the\n    // assigned model's cap) the operator should review before billing.\n    process.stdout.write(\n      `${JSON.stringify(\n        {\n          ok: true,\n          total_nodes: result.canvas.nodes.length,\n          estimated_credits: result.estimatedCredits,\n          cost_preview: result.perNodeCredits ?? [],\n          style_projection: prepared.projections.style,\n          scene_projection: prepared.projections.scenes,\n          canvas_updated: prepared.written,\n          normalized_paths: prepared.rewrites,\n          warnings: [...(result.warnings ?? []), ...(await outputRatioWarningsFor(prepared.canvas, filePath))],\n        },\n        null,\n        2,\n      )}\\n`,\n    );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,UAAU;AACjB,SAAS,qBAAqB;AASvB,IAAM,kBAAkB,cAAc;AAAA,EAC3C,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aACE;AAAA,EACJ;AAAA,EACA,MAAM,EAAE,MAAM,EAAE,MAAM,cAAc,UAAU,MAAM,aAAa,sBAAsB,EAAE;AAAA,EACzF,MAAM,IAAI,EAAE,KAAK,GAAG;AAClB,UAAM,WAAW,KAAK,QAAQ,OAAO,KAAK,IAAI,CAAC;AAE/C,UAAM,OAAO,2BAA2B,QAAQ,KAAK;AACrD,UAAM,WAAW,QAEX,MAAM,cAAc;AAAA,MAClB,YAAY,kBAAkB,QAAQ;AAAA,MACtC;AAAA,MACA,aAAa,KAAK,QAAQ,QAAQ;AAAA,MAClC,QAAQ,eAAe;AAAA,MACvB,QAAQ;AAAA,IACV,CAAC,GACD,WACF;AACJ,QAAI;AACJ,QAAI;AACF,iBAAW,MAAM,cAAc,UAAU;AAAA,QACvC,MAAM;AAAA,QACN,KAAK,CAAC,SAAS,QAAQ,OAAO,MAAM,GAAG,IAAI;AAAA,CAAI;AAAA,QAC/C,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC;AAAA,MACjC,CAAC;AAAA,IACH,SAAS,GAAG;AACV,yBAAmB,CAAC;AAAA,IACtB;AAEA,UAAM,SAAS,MAAM,mBAAmB,SAAS,QAAQ,gBAAgB,CAAC;AAC1E,QAAI,CAAC,OAAO,IAAI;AACd,cAAQ,OAAO,MAAM,GAAG,KAAK,UAAU,EAAE,IAAI,OAAO,OAAO,EAAE,MAAM,cAAc,QAAQ,OAAO,OAAO,EAAE,GAAG,MAAM,CAAC,CAAC;AAAA,CAAI;AACxH,cAAQ,KAAK,CAAC;AACd;AAAA,IACF;AAKA,YAAQ,OAAO;AAAA,MACb,GAAG,KAAK;AAAA,QACN;AAAA,UACE,IAAI;AAAA,UACJ,aAAa,OAAO,OAAO,MAAM;AAAA,UACjC,mBAAmB,OAAO;AAAA,UAC1B,cAAc,OAAO,kBAAkB,CAAC;AAAA,UACxC,kBAAkB,SAAS,YAAY;AAAA,UACvC,kBAAkB,SAAS,YAAY;AAAA,UACvC,gBAAgB,SAAS;AAAA,UACzB,kBAAkB,SAAS;AAAA,UAC3B,UAAU,CAAC,GAAI,OAAO,YAAY,CAAC,GAAI,GAAI,MAAM,uBAAuB,SAAS,QAAQ,QAAQ,CAAE;AAAA,QACrG;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA;AAAA,IACH;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/variant-5TRRSYBB.js

@@ -0,0 +1,338 @@
+import {
+  nextVariantNumber,
+  repointFile,
+  variantNumberOf,
+  variantOfSlug,
+  variantSlug
+} from "./chunk-LA6PPSNA.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  apiPost
+} from "./chunk-XDZVBX6L.js";
+import "./chunk-N5O67GK5.js";
+import "./chunk-EE72SSB2.js";
+import {
+  registerSchema
+} from "./chunk-WNSE7N75.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/variant.ts
+import { randomUUID } from "crypto";
+import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+registerSchema({
+  command: "landing.variant",
+  description: "Create a new variant of a page, for an A/B test. The variant shares the page's sections instead of copying them, so the only difference between the two is the one you fork \u2014 which is the only way the test measures what you think it measures. Run `baker experiment plan` FIRST: most pages cannot settle most questions.",
+  args: {
+    page: { type: "string", description: "The page to make a variant of, by slug", required: true },
+    fork: {
+      type: "string",
+      description: "The component the variant owns its own copy of, named as it appears under _components/ (`Hero.astro`, or `hero/Card.astro`). Repeat for several. Everything else is shared with the control, so a later edit to the control reaches both arms and cannot skew the test.",
+      required: false
+    },
+    because: {
+      type: "string",
+      description: "What you SAW that makes this worth building \u2014 the observation, not the change. Required here, before the page exists, because a reason written afterwards is a caption for a page rather than the reason for one.",
+      required: true
+    },
+    change: {
+      type: "string",
+      description: "What is different about this version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D.",
+      required: true
+    }
+  }
+});
+var SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+async function readInternalId(definitionPath) {
+  try {
+    const text = await readFile(definitionPath, "utf8");
+    return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function archivedVariantNumbers(root, internalId) {
+  if (!internalId) return [];
+  try {
+    const entries = await readdir(path.resolve(root, "src/_variants", internalId), { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => Number(entry.name)).filter((n) => Number.isInteger(n) && n > 0);
+  } catch {
+    return [];
+  }
+}
+function fail(code, message, fix) {
+  process.stderr.write(
+    `${JSON.stringify({ ok: false, error: { code, message, ...fix ? { fix } : {} } }, null, 2)}
+`
+  );
+  process.exit(2);
+}
+async function isDir(p) {
+  try {
+    return (await stat(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function exists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listLandingSlugs(root) {
+  try {
+    const entries = await readdir(path.resolve(root, "src", "pages"), { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+async function listComponents(componentsDir, prefix = "") {
+  let entries;
+  try {
+    entries = await readdir(componentsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) out.push(...await listComponents(path.join(componentsDir, entry.name), rel));
+    else if (entry.name.endsWith(".astro")) out.push(rel);
+  }
+  return out.sort();
+}
+function resolveForkName(requested, available) {
+  const cleaned = requested.replace(/^\.?\/?(_components\/)?/, "");
+  for (const candidate of [cleaned, `${cleaned}.astro`]) {
+    if (available.includes(candidate)) return candidate;
+  }
+  const basename = (p) => p.slice(p.lastIndexOf("/") + 1);
+  const matches = available.filter((a) => basename(a) === cleaned || basename(a) === `${cleaned}.astro`);
+  return matches.length === 1 ? matches[0] ?? null : null;
+}
+function parseForks(fork, rawArgs) {
+  const names = repeatedValues(rawArgs, "fork", fork).flatMap((s) => s.split(",")).map((s) => s.trim()).filter((s) => s.length > 0);
+  return [...new Set(names)];
+}
+function pageInTest(status, page) {
+  for (const test of status.experiments) {
+    if (test.landingSlug !== page) continue;
+    if (test.status !== "finished") {
+      return `${page} is already in a test (${test.experimentId}, against ${test.variantSlug}, ${test.status}). One page has one test at a time \u2014 read it with \`baker experiment status --landing ${page}\`, and end it with \`baker experiment finish\` before building the next version.`;
+    }
+    if (test.fold === "owed" || test.fold === "landing") {
+      return `The last test on ${page} was won by ${test.variantSlug}, and the page is still being updated to match \u2014 run \`baker experiment fold\` and publish before building the next version.`;
+    }
+  }
+  return null;
+}
+function buildVariantDefinition(controlDefinition, opts) {
+  const frontmatter = controlDefinition.match(/^---\n[\s\S]*?\n---/)?.[0] ?? "---\n---";
+  let out = frontmatter;
+  out = out.replace(/^internalId:.*$/m, `internalId: "${opts.internalId}"`);
+  out = out.replace(/^internalTitle:\s*(.*)$/m, (_m, title) => `internalTitle: ${title.trim()} (variant)`);
+  const shared = opts.forks.length > 0 ? opts.forks.join(", ") : "nothing yet";
+  const note = [
+    "",
+    `# Version ${variantNumberOf(opts.variantSlug) ?? "?"} of \`${opts.controlSlug}\` \u2014 for an A/B test`,
+    "",
+    `This is not a page. It is one version of \`${opts.controlSlug}\`, shown to half of that page's visitors while a test runs; the address bar keeps saying \`/${opts.controlSlug}/\` and this folder has no address of its own. Everything about the page \u2014 the campaign, the audience, the offer, the proof \u2014 is in \`src/pages/${opts.controlSlug}/_definition.md\`, and that is where it is edited. This file only says what is different here.`,
+    "",
+    `**Only this differs:** ${shared}. Every other section is imported from \`${opts.controlSlug}\`, on purpose \u2014 an edit to the page reaches both versions, so the test keeps measuring the one difference rather than a drift between two copies. Edit only the files under \`src/pages/${opts.variantSlug}/_components/\`.`,
+    ...opts.because ? ["", `**Because:** ${opts.because}`] : [],
+    ...opts.change ? ["", `**We changed:** ${opts.change}`] : [],
+    "",
+    `Run \`baker experiment start --landing ${opts.controlSlug} --variant ${opts.variantSlug} --because "\u2026" --change "\u2026"\` to begin, and read the result with \`baker experiment status\`. When the test ends, \`baker experiment fold\` moves the version that won into the page and removes this folder.`,
+    ""
+  ].join("\n");
+  return `${out.trimEnd()}
+${note}`;
+}
+async function resolveTargets(projectRoot, opts) {
+  const { controlSlug } = opts;
+  if (!SLUG_RE.test(controlSlug)) {
+    fail(
+      "INVALID_SLUG",
+      `"${controlSlug}" is not a page slug \u2014 use the folder name directly under src/pages/ (lowercase letters, digits and dashes).`,
+      { argument: "page", availableSlugs: await listLandingSlugs(projectRoot) }
+    );
+  }
+  if (variantOfSlug(controlSlug) !== null) {
+    fail(
+      "INVALID_SLUG",
+      `"${controlSlug}" is already a variant of "${variantOfSlug(controlSlug)}". Make the next variant of the page itself: \`baker landing variant ${variantOfSlug(controlSlug)}\`.`
+    );
+  }
+  const controlDir = path.resolve(projectRoot, "src", "pages", controlSlug);
+  if (!await isDir(controlDir)) {
+    fail("NOT_FOUND", `No page at src/pages/${controlSlug}/`, {
+      availableSlugs: await listLandingSlugs(projectRoot)
+    });
+  }
+  if (!await exists(path.join(controlDir, "index.astro"))) {
+    fail("NOT_FOUND", `src/pages/${controlSlug}/index.astro is missing, so there is no page to make a variant of.`);
+  }
+  const internalId = await readInternalId(path.join(controlDir, "_definition.md"));
+  const variantSlugValue = variantSlug(
+    controlSlug,
+    nextVariantNumber(
+      controlSlug,
+      await listLandingSlugs(projectRoot),
+      await archivedVariantNumbers(projectRoot, internalId)
+    )
+  );
+  const variantDir = path.resolve(projectRoot, "src", "pages", variantSlugValue);
+  const available = await listComponents(path.join(controlDir, "_components"));
+  const forks = [];
+  for (const name of parseForks(opts.fork, opts.rawArgs)) {
+    const resolved = resolveForkName(name, available);
+    if (resolved === null) {
+      fail("NOT_FOUND", `"${name}" is not a component of ${controlSlug}.`, {
+        availableComponents: available,
+        hint: "Name it as it appears under _components/ \u2014 `Hero.astro`, or `hero/Card.astro`."
+      });
+    }
+    forks.push(resolved);
+  }
+  return { controlDir, variantDir, variantSlug: variantSlugValue, available, forks };
+}
+async function writeVariant(opts) {
+  const { controlDir, variantDir, controlSlug, variantSlug: variantSlug2, forks } = opts;
+  const forkedTargets = new Set(forks.map((f) => path.join(controlDir, "_components", f)));
+  const written = [];
+  const indexText = await readFile(path.join(controlDir, "index.astro"), "utf8");
+  await mkdir(variantDir, { recursive: true });
+  await writeFile(
+    path.join(variantDir, "index.astro"),
+    repointFile(indexText, { fromDir: controlDir, toDir: variantDir, controlDir, variantDir, forkedTargets }),
+    "utf8"
+  );
+  written.push(`src/pages/${variantSlug2}/index.astro`);
+  for (const fork of forks) {
+    const fromFile = path.join(controlDir, "_components", fork);
+    const toFile = path.join(variantDir, "_components", fork);
+    const text = await readFile(fromFile, "utf8");
+    await mkdir(path.dirname(toFile), { recursive: true });
+    await writeFile(
+      toFile,
+      repointFile(text, {
+        fromDir: path.dirname(fromFile),
+        toDir: path.dirname(toFile),
+        controlDir,
+        variantDir,
+        forkedTargets
+      }),
+      "utf8"
+    );
+    written.push(`src/pages/${variantSlug2}/_components/${fork}`);
+  }
+  const controlDefinitionPath = path.join(controlDir, "_definition.md");
+  if (await exists(controlDefinitionPath)) {
+    const definition = buildVariantDefinition(await readFile(controlDefinitionPath, "utf8"), {
+      internalId: randomUUID().replace(/-/g, "").slice(0, 8),
+      variantSlug: variantSlug2,
+      controlSlug,
+      forks,
+      ...opts.because ? { because: opts.because } : {},
+      ...opts.change ? { change: opts.change } : {}
+    });
+    await writeFile(path.join(variantDir, "_definition.md"), definition, "utf8");
+    written.push(`src/pages/${variantSlug2}/_definition.md`);
+  }
+  await mkdir(path.join(variantDir, "_images"), { recursive: true });
+  await writeFile(path.join(variantDir, "_images", ".gitkeep"), "", "utf8");
+  return written;
+}
+var variantCommand = defineCommand({
+  meta: {
+    name: "variant",
+    description: "Create a new variant of a page, for an A/B test. The variant SHARES the page's sections and forks only the component you name, so the two versions differ by exactly the thing you are testing. It is a version of that page, not a page of its own: it is never indexed, never listed, and has no public URL \u2014 both versions answer at the page's own address. Run `baker experiment plan` first \u2014 most pages do not have the traffic to settle most questions."
+  },
+  args: {
+    page: { type: "positional", required: true, description: "The page to make a variant of, by slug" },
+    fork: {
+      type: "string",
+      description: "Component the variant owns its own copy of (`Hero.astro`). Repeat for several."
+    },
+    because: {
+      type: "string",
+      required: true,
+      description: "What you SAW that makes this worth building \u2014 the observation, not the change. Required here, before the page exists, because a reason written afterwards is a caption for a page rather than the reason for one, and a test with no stated belief teaches nothing whichever way it lands. Recorded in the page's notes and passed to `baker experiment start`."
+    },
+    change: {
+      type: "string",
+      required: true,
+      description: "What is different about this version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D."
+    }
+  },
+  async run({ args, rawArgs }) {
+    const projectRoot = process.cwd();
+    const controlSlug = String(args.page);
+    const { controlDir, variantDir, variantSlug: variantSlug2, available, forks } = await resolveTargets(projectRoot, {
+      controlSlug,
+      fork: args.fork,
+      rawArgs
+    });
+    let status;
+    try {
+      const response = await apiPost("/api/experiments/status", {
+        landingSlug: controlSlug
+      });
+      status = response.data;
+    } catch (error) {
+      fail(
+        "UNAVAILABLE",
+        `Could not check whether ${controlSlug} is already in a test (${error instanceof Error ? error.message : String(error)}). Nothing was written \u2014 run \`baker experiment status --landing ${controlSlug}\` and try again.`
+      );
+    }
+    const taken = pageInTest(status, controlSlug);
+    if (taken) fail("CONFLICT", taken, { landing: controlSlug });
+    const written = await writeVariant({
+      controlDir,
+      variantDir,
+      controlSlug,
+      variantSlug: variantSlug2,
+      forks,
+      because: String(args.because),
+      change: String(args.change)
+    });
+    const hints = [
+      forks.length === 0 ? `MISSING --fork: ${variantSlug2} currently renders exactly ${controlSlug}, so a test between them cannot conclude anything. Re-run with --fork <Component>, or copy the one section your change touches into src/pages/${variantSlug2}/_components/ and repoint that import.` : `Edit only src/pages/${variantSlug2}/_components/${forks.join(", ")} \u2014 every other section is shared with ${controlSlug}, and editing a shared one changes both arms at once.`,
+      `Preview both at http://localhost:4321/${controlSlug}/ and http://localhost:4321/${variantSlug2}/ and check they differ only where you meant. Once it is live, only the first of those two answers \u2014 a variant has no public address of its own, and \`/${controlSlug}/?_bkr_preview=b\` is how anyone looks at it.`,
+      `Then: baker experiment start --landing ${controlSlug} --variant ${variantSlug2} --because "${String(args.because)}" --change "${String(args.change)}". Nothing is split until the session is published \u2014 the person publishing is the review of this page.`
+    ];
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          data: {
+            page: controlSlug,
+            slug: variantSlug2,
+            forked: forks,
+            shared: available.filter((c) => !forks.includes(c)),
+            written
+          },
+          hints
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+export {
+  buildVariantDefinition,
+  pageInTest,
+  parseForks,
+  resolveForkName,
+  variantCommand
+};
+//# sourceMappingURL=variant-5TRRSYBB.js.map

package/dist/videos-KEDR4GG3.js

@@ -0,0 +1,39 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/videos/index.ts
+import { defineCommand } from "citty";
+var videosCommand = defineCommand({
+  meta: {
+    name: "videos",
+    description: `Find and manage videos in Baker. Subcommands: search, get, upload, ingest, fetch, describe, delete, retry, tags.
+
+Examples:
+  baker videos search "product demo" --limit 5
+  baker videos search "tutorial" --tags explainer
+  baker videos get <video-id>
+  baker videos upload ./demo.mp4
+  baker videos ingest https://www.youtube.com/watch?v=abc123
+  baker videos fetch https://www.youtube.com/watch?v=abc123 --out ./clips
+  baker videos describe <video-id> --description "Customer testimonial, 30s"
+  baker videos delete <video-id> --dry-run
+  baker videos retry <video-id>                    # process a failed video again
+  baker videos tags                                # list; tags create|update|delete for custom tags
+Full guide: __tooling__/docs/tools/baker/videos.md`
+  },
+  subCommands: {
+    get: () => import("./get-OHU2N7B7.js").then((m) => m.getCommand),
+    group: () => import("./group-D5WXNFCP.js").then((m) => m.groupCommand),
+    search: () => import("./search-VT2KUAH6.js").then((m) => m.searchCommand),
+    upload: () => import("./upload-3YJJ5VID.js").then((m) => m.uploadCommand),
+    ingest: () => import("./ingest-DGDNZWEM.js").then((m) => m.ingestCommand),
+    fetch: () => import("./fetch-YWUVDMUH.js").then((m) => m.fetchCommand),
+    describe: () => import("./describe-L3UC6MIL.js").then((m) => m.describeCommand),
+    delete: () => import("./delete-J7DXPGKD.js").then((m) => m.deleteCommand),
+    retry: () => import("./retry-NBZ7Q6HK.js").then((m) => m.retryCommand),
+    tags: () => import("./tags-AAIFQ6LS.js").then((m) => m.tagsCommand)
+  }
+});
+export {
+  videosCommand
+};
+//# sourceMappingURL=videos-KEDR4GG3.js.map