@koda-sl/baker-cli 0.499.0 → 0.501.0-dev.6e96f50b9

package/dist/ideas-ADQFXOI4.js

@@ -0,0 +1,43 @@
+import {
+  buildNext,
+  compactIdea,
+  ideasCommand,
+  ideasHints,
+  ideasReport
+} from "./chunk-7VBKTCX3.js";
+import "./chunk-DQVI7GCX.js";
+import "./chunk-EKX37C3T.js";
+import "./chunk-2PQXUN3X.js";
+import "./chunk-23YNUSLR.js";
+import "./chunk-X4A7NEBZ.js";
+import "./chunk-Y35WFNKZ.js";
+import "./chunk-QPESDKZC.js";
+import "./chunk-E44NXCTL.js";
+import "./chunk-EJGAJHLB.js";
+import "./chunk-PSYAT3ZM.js";
+import "./chunk-3ZW3NYI6.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-LNNTHEL7.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-MWD6JTOY.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-PTRCB7AR.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  buildNext,
+  compactIdea,
+  ideasCommand,
+  ideasHints,
+  ideasReport
+};
+//# sourceMappingURL=ideas-ADQFXOI4.js.map

package/dist/images-X7Z34JXA.js

@@ -0,0 +1,92 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/index.ts
+import { defineCommand } from "citty";
+var imagesCommand = defineCommand({
+  meta: {
+    name: "images",
+    description: `Find, source, and normalize images. Subcommands route by provider so cost + license are explicit.
+
+Library + search:
+  baker images library <q>              Search the company library (replaces search)
+  baker images find <q> --sources \u2026     Fanout: library first, then opt-in providers
+
+External providers:
+  baker images stock <q> [--type \u2026]                    Free stock \u2014 Pexels photos + Pixabay illustrations/vectors
+  baker images google <q>                              Google Images via the official Custom Search API
+  baker images pinterest <q>                           Pinterest reference imagery via ScrapeCreators (photo-real mood boards)
+  baker images logo <domain>                           Brand logo via Brandfetch CDN
+  baker images icon <name> [--set \u2026]                   Iconify (200+ sets)
+  baker images meme <reaction> [--auto-ingest N]       The real, well-known meme template for a reaction (Imgflip)
+  baker images gif <q> [--trending]                    Giphy GIFs / reaction memes (paid-social creative)
+  baker images sticker <q> [--trending]                Giphy stickers \u2014 transparent overlays for ad creative
+  baker images extract <url>                           Firecrawl page extract
+  baker images screenshot <url>                        ScreenshotOne capture
+
+Making new imagery lives in its own family \u2014 baker studio generate / baker studio animate. See __tooling__/docs/tools/baker/studio.md
+
+Library writes (run on the Convex backend):
+  baker images ingest <url> --source <enum>            Save remote URL to library
+  baker images use <url>                               Ingest and wait for ready
+  baker images upload ./file                           Upload local file
+  baker images get <id>                                Get a single record
+  baker images group <id>                              Every image that arrived in the same set (carousel, page scrape)
+  baker images delete <id>                             Delete a record
+  baker images retry <id>                              Process a failed image (status 'error') again
+  baker images describe <id> --description "\u2026"         Correct a wrong name/description/tags \u2014 what library search reads on
+
+Local transforms (operate on files in the sandbox, before upload):
+  baker images download <url|imageId\u2026> [--out \u2026]      Remote URL or library image \u2192 local file (never use curl)
+  baker images normalize <files> [--color \u2026] [--remove-bg] [--height N | --width N | --size WxH]
+                                                       Declarative recolor + bg removal + trim + resize
+  baker images crop <file> --x N --y N --width N --height N
+                                                       Coordinate-based rectangular extract
+  baker images dimensions <file-or-url>                Width / height / aspect / format without decoding the full image
+
+Taxonomy:
+  baker images tags                                    List available image tag names (defaults + company custom tags)
+  baker images tags create|update|delete <name>        Manage the company's custom tags (shared with videos and testimonials)
+
+Paid transforms (run on the Convex backend, cost-tracked):
+  baker images upscale <imageId>                       Real-ESRGAN super-resolution ($0.05/image, waits for completion)
+  baker images upscale <imageId> --remove              Drop the upscaled copy, back to the original (free)
+  baker images layerize <imageId>                      Split into editable layers; recovers baked-in copy as editable text (costs credits)
+  baker images layers <imageId>                        Read the layers of an already-split image (free)
+Full guide: __tooling__/docs/tools/baker/images.md`
+  },
+  subCommands: {
+    get: () => import("./get-UOXXHYXJ.js").then((m) => m.getCommand),
+    group: () => import("./group-JROMVKDU.js").then((m) => m.groupCommand),
+    library: () => import("./library-OLXEGJ73.js").then((m) => m.libraryCommand),
+    find: () => import("./find-FHM5R2XW.js").then((m) => m.findCommand),
+    stock: () => import("./stock-4AQFDZLE.js").then((m) => m.stockCommand),
+    google: () => import("./google-AFV6DMTA.js").then((m) => m.googleCommand),
+    pinterest: () => import("./pinterest-PONS4KLN.js").then((m) => m.pinterestCommand),
+    logo: () => import("./logo-UJIVQZRI.js").then((m) => m.logoCommand),
+    icon: () => import("./icon-XO2EKLWL.js").then((m) => m.iconCommand),
+    meme: () => import("./meme-LVRZR7XL.js").then((m) => m.memeCommand),
+    gif: () => import("./gif-2D6UXHP5.js").then((m) => m.gifCommand),
+    sticker: () => import("./sticker-CJ6Y36AO.js").then((m) => m.stickerCommand),
+    extract: () => import("./extract-55YRHNCV.js").then((m) => m.extractCommand),
+    screenshot: () => import("./screenshot-CREF7FB4.js").then((m) => m.screenshotCommand),
+    ingest: () => import("./ingest-QEOAUEKH.js").then((m) => m.ingestCommand),
+    use: () => import("./use-J3TZJZ4M.js").then((m) => m.useCommand),
+    search: () => import("./search-7343MBTZ.js").then((m) => m.searchCommand),
+    upload: () => import("./upload-5237F4WV.js").then((m) => m.uploadCommand),
+    delete: () => import("./delete-GPTU4DJ5.js").then((m) => m.deleteCommand),
+    retry: () => import("./retry-7RQ44CSW.js").then((m) => m.retryCommand),
+    describe: () => import("./describe-DUPBGFKA.js").then((m) => m.describeCommand),
+    download: () => import("./download-NNDBNAVZ.js").then((m) => m.downloadCommand),
+    normalize: () => import("./normalize-BREMV3IB.js").then((m) => m.normalizeCommand),
+    crop: () => import("./crop-NBVWWXF2.js").then((m) => m.cropCommand),
+    dimensions: () => import("./dimensions-M4LMNCBV.js").then((m) => m.dimensionsCommand),
+    layerize: () => import("./layerize-M5XLTCO4.js").then((m) => m.layerizeCommand),
+    layers: () => import("./layerize-M5XLTCO4.js").then((m) => m.layersCommand),
+    upscale: () => import("./upscale-KLMXV6JG.js").then((m) => m.upscaleCommand),
+    tags: () => import("./tags-ZWL3G4XR.js").then((m) => m.tagsCommand)
+  }
+});
+export {
+  imagesCommand
+};
+//# sourceMappingURL=images-X7Z34JXA.js.map

package/dist/ingest-3YB37P3B.js

@@ -0,0 +1,24 @@
+import {
+  ingestCommand,
+  ingestHints,
+  runVideoIngest
+} from "./chunk-2NQ4KZMC.js";
+import "./chunk-FKOECEVC.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-MWD6JTOY.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-PTRCB7AR.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  ingestCommand,
+  ingestHints,
+  runVideoIngest
+};
+//# sourceMappingURL=ingest-3YB37P3B.js.map

package/dist/ingest-QEOAUEKH.js

@@ -0,0 +1,108 @@
+import {
+  imageSourceSchema
+} from "./chunk-MWD6JTOY.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-PTRCB7AR.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema,
+  writeJson,
+  writeOutput
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/ingest.ts
+import { defineCommand } from "citty";
+var SOURCE_VALUES = imageSourceSchema.options.join(" | ");
+registerSchema({
+  command: "images.ingest",
+  description: "Ingest a remote image URL into the library (full describe + embed).",
+  args: {
+    url: { type: "string", description: "Image URL to ingest", required: true },
+    source: { type: "string", description: `Where the image came from. One of: ${SOURCE_VALUES}`, required: true },
+    "external-id": { type: "string", description: "Provider asset id", required: false },
+    "external-url": { type: "string", description: "Canonical page URL", 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 }
+  }
+});
+var ingestCommand = defineCommand({
+  meta: {
+    name: "ingest",
+    description: "Download a remote URL and store it in the library. Hash-deduped on bytes + externalId.\n\nExample: baker images ingest https://images.pexels.com/photos/13219418/pexels-photo-13219418.jpeg --source pexels --external-id 13219418"
+  },
+  args: {
+    url: { type: "positional", description: "Image URL", required: false },
+    source: { type: "string", description: `Where the image came from. One of: ${SOURCE_VALUES}`, required: false },
+    "external-id": { type: "string", description: "Provider asset id", required: false },
+    "external-url": { type: "string", description: "Canonical page URL", required: false },
+    context: { type: "string", description: "Description context", 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 }
+  },
+  run: async ({ args }) => {
+    try {
+      const url = args.url;
+      const source = args.source;
+      if (!url) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "URL is required" } });
+        process.exit(1);
+      }
+      if (!source) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "--source is required",
+            fix: `Pass one of: ${SOURCE_VALUES}. Use "website" for an asset pulled off a company's own site.`
+          }
+        });
+        process.exit(1);
+      }
+      const parsedSource = imageSourceSchema.safeParse(source);
+      if (!parsedSource.success) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: `--source "${source}" is not a known image source`,
+            fix: `Pass one of: ${SOURCE_VALUES}. Use "website" for an asset pulled off a company's own site.`
+          }
+        });
+        process.exit(1);
+      }
+      const body = { url, source: parsedSource.data };
+      if (args["external-id"]) body.externalId = args["external-id"];
+      if (args["external-url"]) body.externalUrl = args["external-url"];
+      if (args.context) body.descriptionContext = args.context;
+      const data = await apiPost("/api/images/ingest", body);
+      writeOutput(
+        { ok: true, data },
+        args.output || "json",
+        args.fields ? args.fields.split(",") : void 0,
+        false,
+        (record) => record
+      );
+    } 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 {
+  ingestCommand
+};
+//# sourceMappingURL=ingest-QEOAUEKH.js.map

package/dist/insights-FEDPCRAC.js

@@ -0,0 +1,130 @@
+import {
+  CHATGPT_ADS_GRANULARITIES,
+  CHATGPT_ADS_LEVELS,
+  CHATGPT_ADS_METRICS,
+  CHATGPT_ADS_REFERENCE,
+  CHATGPT_ADS_SEGMENTS,
+  chatgptAdsInsightsRequestSchema,
+  insightsRequestFromArgs,
+  runChatgptRead
+} from "./chunk-ZEKW4FKU.js";
+import {
+  syncedFirstHint
+} from "./chunk-TWKZVPOA.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/insights.ts
+import { defineCommand } from "citty";
+var args = {
+  level: {
+    type: "string",
+    description: `What one row is: ${CHATGPT_ADS_LEVELS.join("|")} (default campaign)`,
+    required: false
+  },
+  "campaign-id": { type: "string", description: "Report on one campaign (cmpn_\u2026)", required: false },
+  "ad-group-id": { type: "string", description: "Report on one ad group (adgrp_\u2026)", required: false },
+  "ad-id": { type: "string", description: "Report on one ad (ad_\u2026)", required: false },
+  days: {
+    type: "string",
+    description: "Last N complete days, ending the account's yesterday (default 7)",
+    required: false
+  },
+  since: {
+    type: "string",
+    description: "First day, YYYY-MM-DD, account timezone (instead of --days)",
+    required: false
+  },
+  until: { type: "string", description: "Last day, inclusive, YYYY-MM-DD", required: false },
+  granularity: {
+    type: "string",
+    description: `${CHATGPT_ADS_GRANULARITIES.join("|")} (default none: one total per row)`,
+    required: false
+  },
+  segment: {
+    type: "string",
+    description: `Break rows down by one of ${CHATGPT_ADS_SEGMENTS.join("|")}`,
+    required: false
+  },
+  metrics: {
+    type: "string",
+    description: `CSV of ${CHATGPT_ADS_METRICS.join(",")} (default impressions,clicks,spend,ctr,cpc,conversions,cpa)`,
+    required: false
+  },
+  sort: { type: "string", description: "Metric to rank rows by, highest first", required: false },
+  limit: { type: "string", description: "Rows, 1-2000 (default 200)", required: false }
+};
+registerSchema({
+  command: "ads.chatgpt.insights",
+  description: "Performance of the connected ChatGPT Ads account: impressions, clicks, spend, CTR, CPC, CPM, conversions, CPA, attributed sales and ROAS, per account, campaign, ad group or ad, over a window, optionally per day and broken down by country, device, platform or product. Spend and costs are in the account currency; null means not reported, not zero.",
+  args
+});
+function insightsHints(report) {
+  const hints = [];
+  if (report.rows.length === 0) {
+    hints.push(
+      "No delivery in this window. Check `baker ads chatgpt campaigns` for serving issues before concluding the ads do not work."
+    );
+  }
+  if (report.truncated) {
+    hints.push("More rows matched than --limit allowed. Narrow the report or raise --limit (max 2000).");
+  }
+  hints.push(
+    "Conversions come from ChatGPT Ads' own pixel or Conversions API and take at least a day to appear; the most recent days are still filling in."
+  );
+  return hints;
+}
+function chatgptInsightsHints(report, request) {
+  const hints = insightsHints(report);
+  return request.segment ? hints : [...hints, syncedFirstHint("chatgpt", request.level)];
+}
+var insightsCommand = defineCommand({
+  meta: {
+    name: "insights",
+    description: `How a ChatGPT Ads account performs. Start here for "how are the ChatGPT campaigns doing".
+
+Examples:
+  baker ads chatgpt insights                                          # last 7 days, one row per campaign
+  baker ads chatgpt insights --days 30 --granularity daily --level account
+  baker ads chatgpt insights --campaign-id cmpn_123 --level ad --sort spend
+  baker ads chatgpt insights --segment country --metrics spend,clicks,conversions
+  baker ads chatgpt insights --since 2026-09-01 --until 2026-09-07 --metrics spend,order_created_roas`
+  },
+  args,
+  run: async ({ args: input }) => {
+    const parsed = chatgptAdsInsightsRequestSchema.safeParse(insightsRequestFromArgs(input));
+    if (!parsed.success) {
+      const message = parsed.error.issues[0]?.message ?? "Invalid report request";
+      writeJsonEnvelope({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message,
+          fix: { action: "retry_with_modified_query", explanation: message },
+          retryable: false
+        }
+      });
+      process.exit(1);
+    }
+    await runChatgptRead(
+      CHATGPT_ADS_REFERENCE.insights,
+      () => apiPost("/api/ads/chatgpt/insights", parsed.data),
+      (report) => chatgptInsightsHints(report, parsed.data)
+    );
+  }
+});
+export {
+  chatgptInsightsHints,
+  insightsCommand
+};
+//# sourceMappingURL=insights-FEDPCRAC.js.map

package/dist/inspect-N2XWYHLO.js

@@ -0,0 +1,190 @@
+import {
+  fetchRunRecord
+} from "./chunk-4IBP7ENG.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-EJGAJHLB.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-MWD6JTOY.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-PTRCB7AR.js";
+import {
+  ApiError
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/canvas/inspect.ts
+import { execFile } from "child_process";
+import { readdir, readFile, stat } from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+import { defineCommand } from "citty";
+var execFileAsync = promisify(execFile);
+var inspectCommand = defineCommand({
+  meta: {
+    name: "inspect",
+    description: "Dump a one-page summary of a canvas run: per-node duration + cache status, the run's outputs, and optionally three thumbnail frames per video output. Pass a run_id (r_\u2026) or an absolute run directory. A run whose folder is not in this workspace (an older version, or one rendered in another chat) is read from the company's run history instead: its status, stats, per-node results and the durable URL of every output."
+  },
+  args: {
+    run: { type: "positional", required: true, description: "Run id (e.g. r_01K...) or absolute run directory" },
+    "outputs-dir": { type: "string", description: "Per-run outputs root (default <workspace root>/canvas, where `canvas run` writes)" },
+    thumbnails: {
+      type: "boolean",
+      description: "Extract start/middle/end frames from every video output in the local run folder (requires ffmpeg)"
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    const outputsDir = args["outputs-dir"] ? path.resolve(String(args["outputs-dir"])) : path.join(findWorkspaceRoot(cwd) ?? cwd, "canvas");
+    const runArg = String(args.run);
+    const runDir = await localRunDir(runArg, outputsDir);
+    if (!runDir) {
+      if (path.isAbsolute(runArg)) fail("not_found", `${runArg} is not a run directory`);
+      await inspectFromHistory(runArg, path.join(outputsDir, runArg));
+      return;
+    }
+    const manifest = await loadManifest(runDir);
+    const files = await listRunFiles(runDir);
+    const videos = files.filter((f) => isVideoFile(f.path));
+    let thumbnails = [];
+    if (args.thumbnails) {
+      thumbnails = await extractThumbnails(videos.map((v) => v.path));
+    }
+    const summary = {
+      ok: true,
+      source: "local",
+      run_id: manifest.run_id ?? path.basename(runDir),
+      run_dir: runDir,
+      stats: manifest.stats ?? null,
+      output: manifest.output ?? null,
+      node_runs: manifest.node_runs ?? [],
+      files: files.map((f) => ({ name: f.name, path: f.path, size_bytes: f.size })),
+      thumbnails
+    };
+    process.stdout.write(`${JSON.stringify(summary, null, 2)}
+`);
+  }
+});
+async function localRunDir(run, outputsDir) {
+  const candidate = path.isAbsolute(run) ? run : path.join(outputsDir, run);
+  const s = await stat(candidate).catch(() => null);
+  return s?.isDirectory() ? candidate : null;
+}
+async function inspectFromHistory(runId, expectedDir) {
+  let run;
+  try {
+    run = await fetchRunRecord(runId);
+  } catch (e) {
+    const reason = e instanceof ApiError ? e.message : e instanceof Error ? e.message : String(e);
+    fail("unavailable", `No run folder at ${expectedDir}, and the run history could not be read (${reason}).`);
+  }
+  if (!run) {
+    fail(
+      "not_found",
+      `No run "${runId}": there is no folder at ${expectedDir} and the company's run history has no run by that id.`
+    );
+  }
+  const summary = {
+    ok: true,
+    source: "run_history",
+    run_id: run.runId,
+    creative: run.creativeSlug ?? null,
+    status: run.status,
+    ...run.errorMessage ? { error: run.errorMessage } : {},
+    stats: {
+      total_nodes: run.stats.totalNodes,
+      cached_nodes: run.stats.cachedNodes,
+      total_credits: run.stats.totalCredits,
+      duration_ms: run.stats.durationMs
+    },
+    outputs: run.finalOutputs,
+    node_runs: run.nodes.map((node) => ({
+      node_id: node.nodeId,
+      node_type: node.nodeType,
+      cached: node.cached,
+      duration_ms: node.durationMs,
+      credits: node.credits,
+      ...node.status ? { status: node.status } : {},
+      outputs: node.outputs
+    })),
+    ...run.review ? { review: run.review } : {},
+    hints: [
+      "This run's folder is not in this workspace, so there are no local files: every output above is a durable URL. To render it again here, run `baker canvas run --slug <creative>`."
+    ]
+  };
+  process.stdout.write(`${JSON.stringify(summary, null, 2)}
+`);
+}
+function fail(code, message) {
+  process.stderr.write(`${JSON.stringify({ ok: false, error: { code, message } }, null, 2)}
+`);
+  process.exit(2);
+}
+async function loadManifest(runDir) {
+  const manifestPath = path.join(runDir, "manifest.json");
+  try {
+    const raw = await readFile(manifestPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function listRunFiles(runDir) {
+  const out = [];
+  const names = await readdir(runDir);
+  for (const name of names) {
+    const abs = path.join(runDir, name);
+    const s = await stat(abs).catch(() => null);
+    if (!s?.isFile()) continue;
+    out.push({ name, path: abs, size: s.size });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+function isVideoFile(p) {
+  return /\.(mp4|webm|mov)$/i.test(p);
+}
+async function extractThumbnails(videoPaths) {
+  const out = [];
+  for (const v of videoPaths) {
+    const duration = await probeDuration(v).catch(() => null);
+    if (duration === null) {
+      out.push({ video: v, frames: [] });
+      continue;
+    }
+    const frames = [];
+    const checkpoints = [0.05, 0.5, 0.95];
+    const base = v.replace(/\.[^.]+$/, "");
+    for (const ratio of checkpoints) {
+      const at = Math.max(0, Math.min(duration * ratio, duration - 0.01));
+      const dest = `${base}__frame_${Math.round(ratio * 100).toString().padStart(2, "0")}.png`;
+      try {
+        await execFileAsync("ffmpeg", ["-ss", at.toFixed(3), "-i", v, "-frames:v", "1", "-y", dest]);
+        frames.push(dest);
+      } catch {
+      }
+    }
+    out.push({ video: v, frames });
+  }
+  return out;
+}
+async function probeDuration(filePath) {
+  const { stdout } = await execFileAsync(
+    "ffprobe",
+    ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", filePath],
+    { encoding: "utf-8" }
+  );
+  return Number.parseFloat(stdout.trim());
+}
+export {
+  inspectCommand
+};
+//# sourceMappingURL=inspect-N2XWYHLO.js.map

package/dist/inspiration-QJNUFRNH.js

@@ -0,0 +1,53 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/inspiration/index.ts
+import { defineCommand } from "citty";
+var inspirationCommand = defineCommand({
+  meta: {
+    name: "inspiration",
+    description: `Reference library of real landing-page sections \u2014 look at how good pages actually solve a problem before you design one.
+
+Start here: \`baker landing inspiration search "<what you want to see>"\` during research, BEFORE you write the Direction Contract.
+
+This is inspiration, never a clipboard. Take the mechanism \u2014 what the eye hits first, what proof arrives before the ask, how the grid is split. The words are never yours to reuse: shipping a reference's headline is a Tier 0 message-match failure.
+
+Subcommands:
+  baker landing inspiration search "<query>"  \u2014 search by look, section type, composition, register or motion; saves screenshots you can Read
+  baker landing inspiration view <id>         \u2014 one section in full: tokens, motion filmstrip, why it works, what to change
+  baker landing inspiration code <id>         \u2014 its standalone HTML+CSS, for structure only
+  baker landing inspiration page <id>         \u2014 a whole page as a sequence: how it orders its sections
+  baker landing inspiration sequences "<q>"   \u2014 what follows what across MANY pages: openers, transitions, closers
+  baker landing inspiration add <url>         \u2014 add a page to the library and save it to this company (returns immediately); --refresh re-studies a page that changed
+  baker landing inspiration favorites         \u2014 what this company has saved; the default search scope
+  baker landing inspiration favorite <id>     \u2014 save a section
+  baker landing inspiration unfavorite <id>   \u2014 unsave a section
+  baker landing inspiration retry-failed      \u2014 study again every saved page that failed
+  baker landing inspiration scrape <url>      \u2014 internal/ops: run the capture locally
+
+Examples:
+  baker landing inspiration search "pricing with a monthly/annual toggle" --max-rank 3
+  baker landing inspiration search "dark developer hero with a terminal" --register dev-tool-minimal --scope all
+  baker landing inspiration search "testimonial wall with faces and company logos" --motion scroll-reveal
+  baker landing inspiration sequences "b2b saas pricing page" --scope all
+  baker landing inspiration add https://linear.app
+
+Full guide: __tooling__/docs/tools/baker/landing.md`
+  },
+  subCommands: {
+    search: () => import("./search-AHMNQDGC.js").then((m) => m.searchCommand),
+    view: () => import("./view-G66NM2IJ.js").then((m) => m.viewCommand),
+    code: () => import("./code-MSWCKVV6.js").then((m) => m.codeCommand),
+    page: () => import("./page-QEJO3QT6.js").then((m) => m.pageCommand),
+    sequences: () => import("./sequences-2P7UQRQT.js").then((m) => m.sequencesCommand),
+    add: () => import("./add-CGHX6D4N.js").then((m) => m.addCommand),
+    favorites: () => import("./favorites-B5L4RBBH.js").then((m) => m.favoritesCommand),
+    favorite: () => import("./favorites-B5L4RBBH.js").then((m) => m.favoriteCommand),
+    unfavorite: () => import("./favorites-B5L4RBBH.js").then((m) => m.unfavoriteCommand),
+    "retry-failed": () => import("./retry-failed-P6KVU263.js").then((m) => m.retryFailedCommand),
+    scrape: () => import("./scrape-ZDBCLPGQ.js").then((m) => m.scrapeCommand)
+  }
+});
+export {
+  inspirationCommand
+};
+//# sourceMappingURL=inspiration-QJNUFRNH.js.map