@koda-sl/baker-cli 0.532.0 → 0.534.0-dev.911a80433

package/dist/publish-LBHYEZW3.js

@@ -0,0 +1,344 @@
+import {
+  advanceDefinitionStatus,
+  definitionPathFor
+} from "./chunk-3ACMDRSE.js";
+import {
+  defaultVideoApiDeps,
+  detectVideoContentType,
+  isVideoFile,
+  uploadLocalVideo,
+  videoProcessingTimeoutMs,
+  waitForPlayableVideo
+} from "./chunk-LXZ5E6AC.js";
+import {
+  defaultImageApiDeps,
+  detectImageContentType,
+  imageProcessingTimeoutMs,
+  publishImageAsCreative,
+  uploadImageBytes,
+  uploadLocalImage,
+  waitForReadyImage
+} from "./chunk-PHZOMTI6.js";
+import {
+  fetchRunRecord
+} from "./chunk-ZKRRYVDG.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-R5LRBDEM.js";
+import {
+  sha256Hex
+} from "./chunk-SVNH6P7O.js";
+import "./chunk-YJYKSMLF.js";
+import "./chunk-L763CNKH.js";
+import "./chunk-DYOUJERF.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MUS2UTWU.js";
+import {
+  ApiError
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import {
+  optionalChatId
+} from "./chunk-VPF5A7CM.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/publish.ts
+import { Buffer } from "buffer";
+import { defineCommand } from "citty";
+var creativeContentTypes = ["image/png", "image/jpeg", "image/webp"];
+var creativeVideoContentTypes = ["video/mp4", "video/quicktime", "video/webm"];
+var UNSUPPORTED_CREATIVE_FILE = "Unsupported creative file extension. Use PNG, JPG or WebP for an image, MP4, MOV or WebM for a video.";
+var DESCRIPTION = `Save a finished creative to Baker Creatives and return a creative reference: a static image (PNG/JPG/WebP) or a finished video render (MP4/MOV/WebM).
+Start here:
+  baker creatives publish ./canvas/r_01K\u2026/final_4x5.png --title "Spring Offer" --slug spring-offer --run-id r_01K\u2026
+  baker creatives publish --title "Spring Offer" --slug spring-offer --run-id r_01K\u2026 --output 4:5
+  baker creatives publish ./canvas/r_01K\u2026/final.mp4 --title "Spring Offer Reel" --slug spring-offer --run-id r_01K\u2026
+With --run-id and no file, every size the run made is saved to the library as one set, the lead size first, and the lead is the creative's cover (--output picks another cover); \`sizes\` names each size's image id. A video goes to the company's video library first and is saved once it plays (up to 3 minutes); it needs the file and --slug. Choose and save the finished version yourself, including in the turn that rendered it. Saving pins that version without recording user approval or putting an ad live. An image publish marks the creative's _definition.md published.`;
+var ARGS = {
+  file: {
+    type: "string",
+    description: "Local creative file: PNG/JPG/WebP image or MP4/MOV/WebM video. Optional for an image with --run-id: the run's saved output is used instead.",
+    required: false
+  },
+  title: { type: "string", description: "Human title for the creative output", required: true },
+  context: { type: "string", description: "Optional describe context for the image asset", required: false },
+  sourceReferenceUrl: {
+    type: "string",
+    description: "Optional URL of the original reference ad",
+    required: false
+  },
+  slug: {
+    type: "string",
+    description: "Creative slug (src/creatives/<slug>/). Attaches the image or video to that creative's row. Required for a video",
+    required: false
+  },
+  runId: {
+    type: "string",
+    description: "Canvas run id (r_\u2026) of the finished generation to pin as published",
+    required: false
+  },
+  output: {
+    type: "string",
+    description: "With --run-id and no file: which of the run's sizes is the creative's cover, by label (e.g. 9:16), slot, or number (1 = first). Every size is saved either way; default the lead. `--output json` is the output format, never a cover.",
+    required: false
+  }
+};
+registerSchema({ command: "creatives.publish", description: DESCRIPTION, args: ARGS });
+var SIZES_HINT = "Each size is its own image: on Meta, stage the 4:5 for Feed and the 9:16 for Stories and Reels (one ad, asset_customization_rules); LinkedIn takes the 1:1.";
+function detectCreativeContentType(filePath) {
+  return detectImageContentType(filePath, {
+    allowedContentTypes: creativeContentTypes,
+    unsupportedMessage: UNSUPPORTED_CREATIVE_FILE
+  });
+}
+function chatIdFromEnv() {
+  return optionalChatId();
+}
+function parseOptionalUrl(value) {
+  if (value === void 0 || value.trim() === "") {
+    return void 0;
+  }
+  try {
+    return new URL(value).toString();
+  } catch {
+    throw new ApiError("VALIDATION_ERROR", "--source-reference-url must be a valid URL");
+  }
+}
+async function downloadBytes(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new ApiError("UNAVAILABLE", `Could not read the run's output (${res.status} ${res.statusText})`);
+  return Buffer.from(await res.arrayBuffer());
+}
+function runImages(run) {
+  if (run.status !== "completed") {
+    throw new ApiError(
+      "VALIDATION_ERROR",
+      `Run ${run.runId} did not finish (${run.status}), so it has no result to publish. Finish the run first, or pass the image file.`
+    );
+  }
+  const finals = run.finalOutputs.filter((o) => typeof o.url === "string");
+  if (finals.some((o) => !creativeContentTypes.some((t) => t === o.mime))) {
+    throw new ApiError(
+      "VALIDATION_ERROR",
+      `Run ${run.runId} made a video, not a still image. Publish the video file: baker creatives publish ./canvas/${run.runId}/<file>.mp4 --slug <slug> --run-id ${run.runId}.`
+    );
+  }
+  return finals;
+}
+function describeOutputs(outputs) {
+  return outputs.map((o, i) => `${i + 1}: ${o.label ?? o.slot}`).join(", ");
+}
+var MASTER_NODE = "master";
+function leadFirst(run, images) {
+  const master = new Set(
+    run.nodes.filter((n) => n.nodeId === MASTER_NODE).flatMap((n) => n.outputs.map((o) => o.sha256))
+  );
+  const at = images.findIndex((o) => master.has(o.sha256));
+  return at > 0 ? [images[at], ...images.filter((_, i) => i !== at)] : [...images];
+}
+function orderedOutputs(run, choice) {
+  const images = leadFirst(run, runImages(run));
+  if (images.length === 0) {
+    throw new ApiError(
+      "VALIDATION_ERROR",
+      `Run ${run.runId} has no saved image to publish. Pass the image file instead.`
+    );
+  }
+  if (choice === void 0) return { outputs: images, cover: 0 };
+  const wanted = choice.trim();
+  const byNumber = /^\d+$/.test(wanted) ? Number(wanted) - 1 : -1;
+  const cover = images[byNumber] ? byNumber : images.findIndex((o) => o.label === wanted || o.slot === wanted);
+  if (cover < 0) {
+    throw new ApiError("VALIDATION_ERROR", `Run ${run.runId} has no output "${wanted}" (${describeOutputs(images)}).`);
+  }
+  return { outputs: images, cover };
+}
+var EXTENSION = { "image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp" };
+async function uploadRunOutputs(args, deps) {
+  const run = await fetchRunRecord(args.runId, deps.post);
+  if (!run) {
+    throw new ApiError(
+      "NOT_FOUND",
+      `No run "${args.runId}" in this company's run history. Pass the image file instead.`
+    );
+  }
+  const { outputs, cover } = orderedOutputs(run, args.output);
+  const sizes = [];
+  for (const [index, chosen] of outputs.entries()) {
+    const bytes = await (deps.download ?? downloadBytes)(String(chosen.url));
+    if (sha256Hex(bytes) !== chosen.sha256) {
+      throw new ApiError(
+        "VALIDATION_ERROR",
+        `The saved output of run ${run.runId} does not match its recorded fingerprint`
+      );
+    }
+    const name = (chosen.label ?? chosen.slot).replace(/[^a-z0-9.-]+/gi, "_");
+    const { imageId } = await uploadImageBytes(
+      {
+        bytes,
+        contentType: chosen.mime,
+        originalFilename: `${run.runId}-${name}${EXTENSION[chosen.mime] ?? ""}`,
+        source: "ai_generated",
+        descriptionContext: args.descriptionContext,
+        ...outputs.length > 1 ? {
+          group: {
+            key: `creative:${args.slug ?? "run"}:${run.runId}`,
+            kind: "creative_sizes",
+            index,
+            size: outputs.length,
+            title: args.title
+          }
+        } : {}
+      },
+      deps
+    );
+    sizes.push({ format: chosen.label ?? chosen.slot, imageId });
+  }
+  return { imageId: sizes[cover]?.imageId ?? "", sizes };
+}
+async function publishCreative(args, deps = defaultImageApiDeps) {
+  const title = args.title.trim();
+  if (!title) {
+    throw new ApiError("VALIDATION_ERROR", "--title is required");
+  }
+  const sourceReferenceUrl = parseOptionalUrl(args.sourceReferenceUrl);
+  const descriptionContext = args.context ?? `Static ad creative: ${title}`;
+  let upload;
+  if (args.file) {
+    upload = await uploadLocalImage(
+      {
+        file: args.file,
+        contentType: detectCreativeContentType(args.file),
+        source: "ai_generated",
+        descriptionContext
+      },
+      deps
+    );
+  } else if (args.runId) {
+    upload = await uploadRunOutputs(
+      {
+        runId: args.runId,
+        output: args.output,
+        descriptionContext,
+        ...args.slug ? { slug: args.slug } : {},
+        title
+      },
+      deps
+    );
+  } else {
+    throw new ApiError("VALIDATION_ERROR", "Pass the image file, or --run-id to save the run's own output");
+  }
+  await waitForReadyImage(deps, upload.imageId, { timeoutMs: imageProcessingTimeoutMs });
+  const saved = await publishImageAsCreative(deps, {
+    imageId: upload.imageId,
+    title,
+    sourceReferenceUrl,
+    slug: args.slug,
+    runId: args.runId,
+    // Attribute the publish to the driving chat (injected by the bridge).
+    chatId: chatIdFromEnv()
+  });
+  const result = upload.sizes && upload.sizes.length > 1 ? { ...saved, sizes: upload.sizes } : saved;
+  if (args.slug && args.runId) {
+    const cwd = process.cwd();
+    const root = deps.workspaceRoot ?? findWorkspaceRoot(cwd) ?? cwd;
+    const status = await advanceDefinitionStatus(definitionPathFor(root, args.slug), "published");
+    if (status === "updated") return { ...result, definitionStatus: "published" };
+  }
+  return result;
+}
+async function publishVideoCreative(args, deps = defaultVideoApiDeps) {
+  const title = args.title.trim();
+  if (!title) {
+    throw new ApiError("VALIDATION_ERROR", "--title is required");
+  }
+  const slug = args.slug?.trim();
+  if (!slug) {
+    throw new ApiError(
+      "VALIDATION_ERROR",
+      "--slug is required for a video: name the creative (src/creatives/<slug>/) this render belongs to"
+    );
+  }
+  const sourceReferenceUrl = parseOptionalUrl(args.sourceReferenceUrl);
+  const contentType = detectVideoContentType(args.file, {
+    allowedContentTypes: creativeVideoContentTypes,
+    unsupportedMessage: UNSUPPORTED_CREATIVE_FILE
+  });
+  const { videoId } = await uploadLocalVideo(
+    { file: args.file, contentType, descriptionContext: args.context ?? `Video ad creative: ${title}` },
+    deps
+  );
+  await waitForPlayableVideo(deps, videoId, { timeoutMs: videoProcessingTimeoutMs });
+  const body = { videoId, title, slug };
+  if (args.runId) body.runId = args.runId;
+  if (sourceReferenceUrl) body.sourceReferenceUrl = sourceReferenceUrl;
+  const chatId = chatIdFromEnv();
+  if (chatId) body.chatId = chatId;
+  return deps.post("/api/creatives/publish-video", body);
+}
+var publishCommand = defineCommand({
+  meta: { name: "publish", description: DESCRIPTION },
+  // Checked in `run` rather than by citty, so a missing value answers with the JSON envelope.
+  args: { ...ARGS, file: { ...ARGS.file, type: "positional" }, title: { ...ARGS.title, required: false } },
+  run: async ({ args }) => {
+    try {
+      const file = args.file;
+      const title = args.title;
+      const runId = args.runId;
+      if (!file && !runId) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Image or video path is required (or --run-id to save the run's own image)"
+          }
+        });
+        process.exit(1);
+      }
+      if (!title) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "--title is required" } });
+        process.exit(1);
+      }
+      const publishArgs = {
+        file: file || void 0,
+        title,
+        context: args.context,
+        sourceReferenceUrl: args.sourceReferenceUrl,
+        slug: args.slug,
+        runId
+      };
+      if (file && isVideoFile(file)) {
+        writeJson(await publishVideoCreative({ ...publishArgs, file }));
+        return;
+      }
+      const data = await publishCreative({
+        ...publishArgs,
+        output: args.output
+      });
+      writeJson({ ok: true, data, ...data.sizes ? { hints: [SIZES_HINT] } : {} });
+    } 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 {
+  detectCreativeContentType,
+  publishCommand,
+  publishCreative,
+  publishVideoCreative
+};
+//# sourceMappingURL=publish-LBHYEZW3.js.map

package/dist/query-A53T6QJF.js

@@ -0,0 +1,62 @@
+import {
+  buildFileSummary,
+  buildQueryEnvelope,
+  completenessWarnings,
+  effectiveRowLimit,
+  keywordServingOptions,
+  missingFieldWarnings,
+  missingFieldWarningsFor,
+  outputResults,
+  pageCacheKey,
+  parseQueryLimit,
+  parseSelectedFields,
+  queryCommand,
+  queryPageSize,
+  resolveGaqlInput,
+  resultColumns,
+  runQuery,
+  servingScopeWarnings,
+  shouldReadCache,
+  summariseWarnings,
+  unobservedFields,
+  unobservedSelectedFields,
+  unwrittenColumnWarnings,
+  warningLines
+} from "./chunk-TOUF5ME6.js";
+import "./chunk-Y2FAUFWK.js";
+import "./chunk-JPK34QPS.js";
+import "./chunk-OI2CKYAQ.js";
+import "./chunk-IZABTTW5.js";
+import "./chunk-LV7EU6HM.js";
+import "./chunk-MUS2UTWU.js";
+import "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  buildFileSummary,
+  buildQueryEnvelope,
+  completenessWarnings,
+  effectiveRowLimit,
+  keywordServingOptions,
+  missingFieldWarnings,
+  missingFieldWarningsFor,
+  outputResults,
+  pageCacheKey,
+  parseQueryLimit,
+  parseSelectedFields,
+  queryCommand,
+  queryPageSize,
+  resolveGaqlInput,
+  resultColumns,
+  runQuery,
+  servingScopeWarnings,
+  shouldReadCache,
+  summariseWarnings,
+  unobservedFields,
+  unobservedSelectedFields,
+  unwrittenColumnWarnings,
+  warningLines
+};
+//# sourceMappingURL=query-A53T6QJF.js.map

package/dist/reddit-H4R23K27.js

@@ -0,0 +1,29 @@
+import {
+  findSubreddits,
+  redditCommand,
+  searchReddit,
+  subredditsFromArgs
+} from "./chunk-E3FMS5DA.js";
+import "./chunk-WEQZ563U.js";
+import "./chunk-QPPQXU3U.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-DYOUJERF.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MUS2UTWU.js";
+import "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  findSubreddits,
+  redditCommand,
+  searchReddit,
+  subredditsFromArgs
+};
+//# sourceMappingURL=reddit-H4R23K27.js.map

package/dist/refresh-3QKUSERK.js

@@ -0,0 +1,97 @@
+import {
+  reportError
+} from "./chunk-E34YYDCE.js";
+import {
+  adLibraryRefreshRequestSchema
+} from "./chunk-DYOUJERF.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MUS2UTWU.js";
+import {
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/refresh.ts
+import { defineCommand } from "citty";
+function refreshEnvelope(data) {
+  if (data.queued) {
+    return {
+      ok: true,
+      data,
+      hints: [
+        "Re-scrape started \u2014 new ads arrive over the next minutes. Check progress with `baker winning-ads following`; carry on with the ads already there meanwhile."
+      ]
+    };
+  }
+  if (data.collecting) {
+    return {
+      ok: true,
+      data,
+      hints: [
+        `${data.label}'s ads are still being collected from the follow or the last refresh, so there is nothing to refresh yet. Check progress with \`baker winning-ads following\` and use what is there meanwhile.`
+      ]
+    };
+  }
+  if (data.nextAllowedAt !== void 0) {
+    const next = new Date(data.nextAllowedAt).toISOString();
+    return {
+      ok: false,
+      error: {
+        code: "RATE_LIMITED",
+        message: `${data.label} was refreshed less than 6 hours ago.`,
+        fix: `Use the ads already collected for ${data.label}; it can be refreshed again after ${next}. Do not retry before then.`
+      }
+    };
+  }
+  return {
+    ok: true,
+    data,
+    hints: ["Nothing new to look for on this brand right now; its ads are already up to date."]
+  };
+}
+registerSchema({
+  command: "winning-ads.refresh",
+  description: "Re-scrape a brand this company follows so its newest ads land in the library. At most once every 6 hours per brand, and not while its ads are still being collected; it costs a fresh scrape, so use it only when the user wants the latest ads.",
+  args: {
+    advertiser: { type: "string", description: "Advertiser id of a followed brand (from `following`)", required: true }
+  }
+});
+var refreshCommand = defineCommand({
+  meta: {
+    name: "refresh",
+    description: "Re-scrape a followed brand for its newest ads (at most once every 6 hours). Example: baker winning-ads refresh adv_123"
+  },
+  args: {
+    advertiser: { type: "positional", description: "Advertiser id of a followed brand", required: true }
+  },
+  run: async ({ args }) => {
+    const parsed = adLibraryRefreshRequestSchema.safeParse({ advertiser_id: String(args.advertiser ?? "") });
+    if (!parsed.success) {
+      writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: parsed.error.issues[0]?.message ?? "" } });
+      process.exit(1);
+    }
+    try {
+      const envelope = refreshEnvelope(await apiPost("/api/ad-library/refresh", parsed.data));
+      writeJson(envelope);
+      if (!envelope.ok) process.exit(1);
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  refreshCommand,
+  refreshEnvelope
+};
+//# sourceMappingURL=refresh-3QKUSERK.js.map

package/dist/release-JMYTQZLK.js

@@ -0,0 +1,63 @@
+import {
+  failApi,
+  failValidation,
+  writeOk
+} from "./chunk-7MY3QHGA.js";
+import "./chunk-DYOUJERF.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MUS2UTWU.js";
+import {
+  apiPost,
+  validateConvexId
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import {
+  requireChatId
+} from "./chunk-VPF5A7CM.js";
+import {
+  registerSchema
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/release.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "actions.release",
+  description: "Release an action you previously claimed (no-op if you don't own the claim).",
+  args: {
+    id: { type: "string", description: "Action ID", required: true }
+  }
+});
+var releaseCommand = defineCommand({
+  meta: {
+    name: "release",
+    description: "Release a claim you made on an action. Example: baker actions release <action-id>"
+  },
+  args: {
+    id: { type: "positional", description: "Action ID", required: false },
+    "action-id": { type: "string", description: "Action ID", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id || args["action-id"];
+      if (!id) {
+        failValidation("Action ID is required.");
+      }
+      validateConvexId(id);
+      const chatId = requireChatId();
+      await apiPost("/api/actions/release", { actionId: id, chatId });
+      writeOk();
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  releaseCommand
+};
+//# sourceMappingURL=release-JMYTQZLK.js.map

package/dist/relevant-pages-DOCKQEMZ.js

@@ -0,0 +1,99 @@
+import {
+  RESEARCH_DATA_NOTE,
+  handleResearchError,
+  writeResearchHints,
+  writeResearchJson,
+  writeResearchOutput
+} from "./chunk-QPPQXU3U.js";
+import {
+  buildResearchQueryContext,
+  warnDefaults
+} from "./chunk-URMAEVZO.js";
+import "./chunk-IZABTTW5.js";
+import "./chunk-MUS2UTWU.js";
+import {
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import {
+  registerSchema
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/research/relevant-pages.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "research.relevant-pages",
+  description: "Get the top pages of a competitor domain with organic traffic and ranking data. Shows which pages drive the most traffic. If --location and --language are omitted, defaults to United States (us) and English (en).",
+  args: {
+    target: { type: "string", description: "Domain to analyze (positional, e.g. competitor.com)", required: true },
+    location: {
+      type: "string",
+      description: "Country code (us, uk, es, de...) or DataForSEO location code. Defaults to us (United States) if omitted",
+      required: false
+    },
+    language: {
+      type: "string",
+      description: "Language code or name. Defaults to en (English) if omitted",
+      required: false
+    },
+    limit: { type: "string", description: "Max results (default: 20, max: 1000)", required: false },
+    "no-cache": { type: "boolean", description: "Skip server cache, hit API directly", required: false }
+  }
+});
+var FIELDS = {
+  page: "Page URL",
+  etv: "Estimated monthly organic traffic",
+  keywords: "Total organic keywords the page ranks for",
+  top_10: "Keywords in positions 1-10"
+};
+var relevantPagesCommand = defineCommand({
+  meta: {
+    name: "relevant-pages",
+    description: `Get the top pages of a competitor domain with traffic data.
+
+Examples:
+  baker research relevant-pages "competitor.com"
+  baker research relevant-pages "competitor.com" --location es --limit 10`
+  },
+  args: {
+    target: { type: "positional", description: "Domain to analyze", required: true },
+    location: { type: "string", description: "Country code or location code (default: us)", required: false },
+    language: { type: "string", description: "Language code or name (default: en)", required: false },
+    limit: { type: "string", description: "Max results (default: 20, max: 1000)", required: false },
+    output: { type: "string", description: "Format: json|csv|md|jsonl", required: false, default: "json" },
+    "no-cache": { type: "boolean", description: "Skip server cache, hit API directly", required: false }
+  },
+  run: async ({ args }) => {
+    const target = args.target;
+    const location = args.location || void 0;
+    const language = args.language || void 0;
+    const limit = args.limit ? Number(args.limit) : void 0;
+    const skipCache = args["no-cache"] ? true : void 0;
+    const queryContext = buildResearchQueryContext(location, language);
+    try {
+      const data = await apiPost("/api/research/relevant-pages", {
+        target,
+        location,
+        language,
+        limit,
+        skipCache
+      });
+      warnDefaults(queryContext);
+      const format = args.output || "json";
+      if (format !== "json") {
+        writeResearchOutput(data, format);
+        writeResearchHints([RESEARCH_DATA_NOTE], format);
+        return;
+      }
+      writeResearchJson({ ok: true, data, fields: FIELDS, note: RESEARCH_DATA_NOTE, query_context: queryContext });
+    } catch (err) {
+      handleResearchError(err);
+    }
+  }
+});
+export {
+  relevantPagesCommand
+};
+//# sourceMappingURL=relevant-pages-DOCKQEMZ.js.map