@koda-sl/baker-cli 0.472.0 → 0.473.0

package/dist/chunk-YHTADMBF.js

@@ -0,0 +1,19 @@
+import {
+  latestVersion
+} from "./chunk-EZTEYFBZ.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-JQUPL6IQ.js";
+
+// src/commands/creatives/version-of.ts
+import path from "path";
+async function versionOf(slug, run) {
+  if (typeof run === "string" && run.trim()) return run.trim();
+  const canvas = path.join("src", "creatives", slug, `${slug}.canvas.json`);
+  return await latestVersion(canvasOutputsRoot(canvas), slug) ?? void 0;
+}
+
+export {
+  versionOf
+};
+//# sourceMappingURL=chunk-YHTADMBF.js.map

package/dist/chunk-Z2HNETUP.js

@@ -0,0 +1,58 @@
+import {
+  readAvatars
+} from "./chunk-SS445HDO.js";
+
+// src/commands/canvas/scaffold-static-ad-paths.ts
+import path from "path";
+function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
+  const file = rawFile.trim();
+  const imageIsUrl = /^https?:\/\//i.test(file);
+  const imageSource = imageIsUrl ? file : path.resolve(cwd, file);
+  const outPath = out ? path.resolve(cwd, out) : slug ? path.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path.join(cwd, "static-ad.canvas.json") : path.join(path.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath = path.join(path.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path.join(creativeDir, "references") : null;
+  return { imageIsUrl, imageSource, outPath, blueprintPath, creativeDir, definitionPath, referencesDir };
+}
+var SCAFFOLD_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var SCAFFOLD_SLUG_MAX_LENGTH = 100;
+function isValidScaffoldSlug(slug) {
+  return slug.length <= SCAFFOLD_SLUG_MAX_LENGTH && SCAFFOLD_SLUG_PATTERN.test(slug);
+}
+
+// src/commands/avatars/resolveCast.ts
+async function resolveCastAvatar(handle) {
+  try {
+    const avatar = await readAvatars("/api/avatars/get", { handle });
+    if (avatar.status && avatar.status !== "ready") {
+      return {
+        error: `Avatar \`${handle}\` is ${avatar.status}, not ready \u2014 \`baker avatars get ${handle} --wait\` returns the moment it is.`
+      };
+    }
+    if (!avatar.sheetUrl)
+      return { error: `Avatar \`${handle}\` has no identity sheet yet, so the ad cannot ground on their face.` };
+    return { sheetUrl: avatar.sheetUrl, subjectDescription: avatar.subjectDescription, handle };
+  } catch (e) {
+    return {
+      error: `Could not read avatar \`${handle}\`: ${e instanceof Error ? e.message : String(e)}. \`baker avatars list\` shows who there is.`
+    };
+  }
+}
+async function resolveCastAvatars(flag) {
+  const handles = String(flag ?? "").split(",").map((h) => h.trim()).filter(Boolean);
+  const avatars = [];
+  for (const handle of handles) {
+    const resolved = await resolveCastAvatar(handle);
+    if ("error" in resolved) return resolved;
+    avatars.push(resolved);
+  }
+  return { handles, avatars };
+}
+
+export {
+  resolveScaffoldStaticAdPaths,
+  isValidScaffoldSlug,
+  resolveCastAvatars
+};
+//# sourceMappingURL=chunk-Z2HNETUP.js.map

package/dist/claim-FPMBDKVA.js

@@ -0,0 +1,197 @@
+import {
+  failApi,
+  failValidation
+} from "./chunk-FAB3BWE2.js";
+import "./chunk-XABVEMC3.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost,
+  validateConvexId
+} from "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import {
+  requireChatId
+} from "./chunk-G3UCXCC2.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-IWLWY2UD.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/claim.ts
+import { defineCommand } from "citty";
+
+// src/commands/actions/skillCatalog.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+var DESCRIPTION_MAX = 600;
+var SKILLS_SUBPATH = join(".claude", "skills");
+var EXCLUDED_SKILLS = /* @__PURE__ */ new Set(["actions"]);
+function stripQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\n/g, "\n");
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).replace(/''/g, "'");
+  }
+  return trimmed;
+}
+function extractFrontmatterLines(md) {
+  if (!md.startsWith("---")) return null;
+  const end = md.indexOf("\n---", 3);
+  if (end === -1) return null;
+  return md.slice(md.indexOf("\n", 3) + 1, end).split("\n");
+}
+var BLOCK_SCALAR = /^([|>])[+-]?$/;
+function collectBlockLines(lines, start) {
+  const collected = [];
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "") {
+      collected.push("");
+    } else if (/^\s/.test(line)) {
+      collected.push(line.trim());
+    } else {
+      break;
+    }
+  }
+  while (collected.length > 0 && collected.at(-1) === "") collected.pop();
+  return collected;
+}
+function foldLines(collected) {
+  const paragraphs = [];
+  let buffer = [];
+  for (const line of collected) {
+    if (line === "") {
+      if (buffer.length > 0) paragraphs.push(buffer.join(" "));
+      buffer = [];
+    } else {
+      buffer.push(line);
+    }
+  }
+  if (buffer.length > 0) paragraphs.push(buffer.join(" "));
+  return paragraphs.join("\n");
+}
+function readBlockScalar(lines, start, style) {
+  const collected = collectBlockLines(lines, start);
+  return style === "|" ? collected.join("\n") : foldLines(collected);
+}
+function readField(lines, field) {
+  for (let i = 0; i < lines.length; i++) {
+    const match = (lines[i] ?? "").match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match || match[1] !== field) continue;
+    const inline = (match[2] ?? "").trim();
+    const scalar = inline.match(BLOCK_SCALAR);
+    if (scalar) {
+      return readBlockScalar(lines, i + 1, scalar[1]);
+    }
+    return stripQuotes(inline);
+  }
+  return null;
+}
+function parseSkillFrontmatter(md) {
+  const lines = extractFrontmatterLines(md);
+  if (!lines) return null;
+  const name = readField(lines, "name");
+  const description = readField(lines, "description");
+  if (!name || !description) return null;
+  const trimmed = description.length > DESCRIPTION_MAX ? `${description.slice(0, DESCRIPTION_MAX)}\u2026` : description;
+  return { name, description: trimmed };
+}
+function findSkillsDir(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    const candidate = join(dir, SKILLS_SUBPATH);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readSkillCatalog(startDir) {
+  const skillsDir = findSkillsDir(startDir);
+  if (!skillsDir) return [];
+  const entries = [];
+  for (const dirent of readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!dirent.isDirectory() || EXCLUDED_SKILLS.has(dirent.name)) continue;
+    const skillFile = join(skillsDir, dirent.name, "SKILL.md");
+    if (!existsSync(skillFile)) continue;
+    try {
+      const parsed = parseSkillFrontmatter(readFileSync(skillFile, "utf8"));
+      if (parsed) entries.push(parsed);
+    } catch {
+    }
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/commands/actions/claim.ts
+registerSchema({
+  command: "actions.claim",
+  description: "Claim an action for the current chat (live \u2014 visible to other chats immediately). Claim only what you're actively working on now: it's required before `complete`, but NOT for `update` or `discard` (those stage without a claim). Returns action details plus a fast-model recommendation of which skills to load for the work (`recommendedSkills`) and a routing hint: load every skill that owns part of the work and the tool doc for each baker CLI family you'll use.",
+  args: {
+    id: { type: "string", description: "Action ID", required: true }
+  }
+});
+async function recommendSkills(actionId) {
+  const skills = readSkillCatalog(process.cwd());
+  if (skills.length === 0) return [];
+  const response = await apiPost("/api/actions/recommend-skills", {
+    actionId,
+    skills
+  });
+  return response.data.recommendations;
+}
+var ROUTING_HINT = "Actions often span several surfaces (a landing page plus a Google Ads change, a sheet pull plus an audience upload). Before starting, load EVERY skill that owns part of the work and read the tool doc (__tooling__/docs/tools/baker/<family>.md) for each baker CLI family you'll use. If the action references source material living in a connected tool (an email attachment, a call, a CRM record, a spreadsheet), reach for that tool too. If it describes recurring or future-dated work, it belongs on a schedule \u2014 see __tooling__/docs/tools/baker/scheduled-agents.md.";
+function buildHints(recommendations) {
+  if (recommendations.length === 0) {
+    return ["Review the action name, description, and tags above.", ROUTING_HINT];
+  }
+  return [
+    "Recommended skills for this action (load the ones you'll use):",
+    ...recommendations.map((r) => `  /${r.name} \u2014 ${r.reason}`),
+    "Suggestions come from the action's name/description/tags only \u2014 the work may need more.",
+    ROUTING_HINT
+  ];
+}
+var claimCommand = defineCommand({
+  meta: {
+    name: "claim",
+    description: "Claim an action so other chats see you're working on it. Required before `complete` (update and discard don't need a claim). Example: baker actions claim <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();
+      const response = await apiPost("/api/actions/claim", {
+        actionId: id,
+        chatId
+      });
+      let recommendedSkills = [];
+      try {
+        recommendedSkills = await recommendSkills(id);
+      } catch {
+      }
+      const data = response.data ? { ...response.data, recommendedSkills } : response.data;
+      writeJson({ ok: response.ok, data, hints: buildHints(recommendedSkills) });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  claimCommand
+};
+//# sourceMappingURL=claim-FPMBDKVA.js.map

package/dist/cli.js

@@ -3,20 +3,20 @@ import {
   cacheFlagForCommand,
   cacheFlagForParser,
   normalizeCacheFlag
-} from "./chunk-Z3GHDRUA.js";
+} from "./chunk-LLN7NP3O.js";
 import {
   installExitRecord,
   installStreamTaps,
   logInvocation
-} from "./chunk-TSOJM4EO.js";
-import "./chunk-5TTHWWON.js";
+} from "./chunk-F4H6VVPE.js";
+import "./chunk-G3UCXCC2.js";
 import {
   commandPathOf,
   installFieldMask,
   outputFlagForCommand,
   refuseUnknownFlags,
   takeFieldsFlag
-} from "./chunk-KCA5CDCU.js";
+} from "./chunk-IWLWY2UD.js";
 import "./chunk-YQSBHWOI.js";
 
 // src/cli.ts
@@ -107,41 +107,41 @@ Formats: --output json works on every command that prints the envelope. --output
 Introspection: Run 'baker schema <command>' to inspect argument schemas.`
   },
   subCommands: {
-    capabilities: () => import("./capabilities-P2FERL4V.js").then((m) => m.capabilitiesCommand),
-    actions: () => import("./actions-IOGUZS4B.js").then((m) => m.actionsCommand),
-    "scheduled-agents": () => import("./scheduled-agents-KUL2LELR.js").then((m) => m.scheduledAgentsCommand),
-    ads: () => import("./ads-A2FDEE7S.js").then((m) => m.adsCommand),
-    brand: () => import("./brand-YZTCJ7ZS.js").then((m) => m.brandCommand),
-    analytics: () => import("./analytics-52JWFPVX.js").then((m) => m.analyticsCommand),
-    experiment: () => import("./experiment-O3XG5YUM.js").then((m) => m.experimentCommand),
-    ga4: () => import("./ga4-HGJHMEK6.js").then((m) => m.ga4Command),
-    gsc: () => import("./gsc-3WR4OWXT.js").then((m) => m.gscCommand),
-    research: () => import("./research-EJ5TE47D.js").then((m) => m.researchCommand),
-    decide: () => import("./decide-V7B5ESCY.js").then((m) => m.decideCommand),
-    creatives: () => import("./creatives-BGHZZQRM.js").then((m) => m.creativesCommand),
-    flows: () => import("./flows-FP6FUVR2.js").then((m) => m.flowsCommand),
-    funnel: () => import("./funnel-RCJNMGFE.js").then((m) => m.funnelCommand),
-    images: () => import("./images-XLTHJ2YE.js").then((m) => m.imagesCommand),
-    studio: () => import("./studio-GYH5EHKO.js").then((m) => m.studioCommand),
-    avatars: () => import("./avatars-PFYG26EX.js").then((m) => m.avatarsCommand),
-    landing: () => import("./landing-22G2T5PT.js").then((m) => m.landingCommand),
-    videos: () => import("./videos-V2LDNGHM.js").then((m) => m.videosCommand),
-    testimonials: () => import("./testimonials-WDH7JJAO.js").then((m) => m.testimonialsCommand),
-    canvas: () => import("./canvas-3R6E63UJ.js").then((m) => m.canvasCommand),
-    tags: () => import("./tags-LAOTJ6HY.js").then((m) => m.tagsCommand),
-    "tag-manager": () => import("./tag-manager-WHUSRBEW.js").then((m) => m.tagManagerCommand),
-    chats: () => import("./chats-XFD6KTCY.js").then((m) => m.chatsCommand),
-    history: () => import("./history-GUAM4N64.js").then((m) => m.historyCommand),
-    credentials: () => import("./credentials-AUVITB4Q.js").then((m) => m.credentialsCommand),
-    hubspot: () => import("./hubspot-AECLWSYY.js").then((m) => m.hubspotCommand),
-    activecampaign: () => import("./activecampaign-77ZXA565.js").then((m) => m.activecampaignCommand),
-    accounts: () => import("./accounts-QVPECQOW.js").then((m) => m.accountsCommand),
-    "winning-ads": () => import("./winning-ads-U7HKJAKP.js").then((m) => m.winningAdsCommand),
-    "media-sources": () => import("./media-sources-NXTBRXSB.js").then((m) => m.mediaSourcesCommand),
-    site: () => import("./site-CYFE737S.js").then((m) => m.siteCommand),
-    mcp: () => import("./mcp-ESIERGUA.js").then((m) => m.mcpCommand),
-    "setup-links": () => import("./setup-links-DG2JGU6C.js").then((m) => m.setupLinksCommand),
-    schema: () => import("./schema-6UQ44CN7.js").then((m) => m.schemaCommand)
+    capabilities: () => import("./capabilities-MLO5VN6N.js").then((m) => m.capabilitiesCommand),
+    actions: () => import("./actions-HYDPRUMY.js").then((m) => m.actionsCommand),
+    "scheduled-agents": () => import("./scheduled-agents-RQK4BPT2.js").then((m) => m.scheduledAgentsCommand),
+    ads: () => import("./ads-Q3373W6W.js").then((m) => m.adsCommand),
+    brand: () => import("./brand-VTAWDOYF.js").then((m) => m.brandCommand),
+    analytics: () => import("./analytics-G7CFO4FR.js").then((m) => m.analyticsCommand),
+    experiment: () => import("./experiment-JF2QTPRV.js").then((m) => m.experimentCommand),
+    ga4: () => import("./ga4-73HIUKOL.js").then((m) => m.ga4Command),
+    gsc: () => import("./gsc-LDZKY5FW.js").then((m) => m.gscCommand),
+    research: () => import("./research-SJYICZEZ.js").then((m) => m.researchCommand),
+    decide: () => import("./decide-DZG2JUMG.js").then((m) => m.decideCommand),
+    creatives: () => import("./creatives-4ZAQ4O2Y.js").then((m) => m.creativesCommand),
+    flows: () => import("./flows-S3LP4EZX.js").then((m) => m.flowsCommand),
+    funnel: () => import("./funnel-K5BGG37Q.js").then((m) => m.funnelCommand),
+    images: () => import("./images-P6M2DCR4.js").then((m) => m.imagesCommand),
+    studio: () => import("./studio-45PDCQJ4.js").then((m) => m.studioCommand),
+    avatars: () => import("./avatars-ATZB2WU3.js").then((m) => m.avatarsCommand),
+    landing: () => import("./landing-C5OTTI2X.js").then((m) => m.landingCommand),
+    videos: () => import("./videos-HE4SPXEF.js").then((m) => m.videosCommand),
+    testimonials: () => import("./testimonials-2FM4P4K4.js").then((m) => m.testimonialsCommand),
+    canvas: () => import("./canvas-CFOSESUM.js").then((m) => m.canvasCommand),
+    tags: () => import("./tags-M4XMZOB6.js").then((m) => m.tagsCommand),
+    "tag-manager": () => import("./tag-manager-4A6JJXVB.js").then((m) => m.tagManagerCommand),
+    chats: () => import("./chats-ZLTD4S7R.js").then((m) => m.chatsCommand),
+    history: () => import("./history-AYFOLWXX.js").then((m) => m.historyCommand),
+    credentials: () => import("./credentials-AGVQYHHU.js").then((m) => m.credentialsCommand),
+    hubspot: () => import("./hubspot-DNRSCVUV.js").then((m) => m.hubspotCommand),
+    activecampaign: () => import("./activecampaign-DEFGV2GB.js").then((m) => m.activecampaignCommand),
+    accounts: () => import("./accounts-UTABLCS6.js").then((m) => m.accountsCommand),
+    "winning-ads": () => import("./winning-ads-LBP23L5Q.js").then((m) => m.winningAdsCommand),
+    "media-sources": () => import("./media-sources-IIF4ABAZ.js").then((m) => m.mediaSourcesCommand),
+    site: () => import("./site-6ZTWH3L7.js").then((m) => m.siteCommand),
+    mcp: () => import("./mcp-AEZUPY2M.js").then((m) => m.mcpCommand),
+    "setup-links": () => import("./setup-links-2OS7DUFY.js").then((m) => m.setupLinksCommand),
+    schema: () => import("./schema-RNVEYR2U.js").then((m) => m.schemaCommand)
   }
 });
 await loadCommands(main, process.argv.slice(2));

package/dist/client-2ABVGUQB.js

@@ -0,0 +1,19 @@
+import {
+  ApiError,
+  apiGet,
+  apiGetWithHeaders,
+  apiPost,
+  validateConvexId
+} from "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import "./chunk-G3UCXCC2.js";
+import "./chunk-IWLWY2UD.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  ApiError,
+  apiGet,
+  apiGetWithHeaders,
+  apiPost,
+  validateConvexId
+};
+//# sourceMappingURL=client-2ABVGUQB.js.map

package/dist/code-GHG7DEPV.js

@@ -0,0 +1,76 @@
+import {
+  INSPIRATION_HINTS,
+  fidelityHint,
+  reportError
+} from "./chunk-RMB2MIOJ.js";
+import {
+  apiGet
+} from "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import "./chunk-G3UCXCC2.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-IWLWY2UD.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/inspiration/code.ts
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+registerSchema({
+  command: "landing.inspiration.code",
+  description: "Write a reference section's standalone HTML+CSS to .baker/inspiration/<id>/ so you can read how it is built. Reference only \u2014 the structure is the lesson, the words are not yours to reuse.",
+  args: {
+    id: { type: "string", description: "Section id from search", required: true },
+    full: { type: "boolean", description: "Print the markup inline as well as writing it", required: false }
+  }
+});
+var codeCommand = defineCommand({
+  meta: {
+    name: "code",
+    description: "Write one reference section's standalone markup to disk. Example: baker landing inspiration code k57abc\u2026 \u2014 read it for structure, then build your own."
+  },
+  args: {
+    id: { type: "positional", description: "Section id from search", required: true },
+    full: { type: "boolean", description: "Also print the markup inline", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id;
+      const data = await apiGet("/api/landing-inspiration/section-code", { id });
+      const dir = path.join(process.cwd(), ".baker", "inspiration", id);
+      await mkdir(dir, { recursive: true });
+      const file = path.join(dir, "section.html");
+      await writeFile(file, data.html);
+      const hints = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
+      const fidelity = fidelityHint(data.fidelity);
+      if (fidelity) hints.push(fidelity);
+      if (data.fidelityNote) hints.push(data.fidelityNote);
+      writeJson({
+        ok: true,
+        data: {
+          id,
+          file: path.relative(process.cwd(), file),
+          bytes: data.html.length,
+          fidelity: data.fidelity,
+          reproduction_notes: data.reproductionNotes,
+          adaptation_notes: data.adaptationNotes,
+          source_url: data.sourceUrl,
+          // Behind --full with the markup it belongs to. Up to 60 custom-property
+          // *names*, one per line, was over half the default response — and the
+          // file on disk already has them, next to the values that give them
+          // meaning. A list of variable names on its own decides nothing.
+          ...args.full ? { css_custom_properties: data.cssCustomProperties, html: data.html } : {}
+        },
+        hints
+      });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+export {
+  codeCommand
+};
+//# sourceMappingURL=code-GHG7DEPV.js.map

package/dist/companies-YIKSECXA.js

@@ -0,0 +1,195 @@
+import {
+  csvOrJson,
+  handleLinkedinError
+} from "./chunk-3YOS7IS2.js";
+import {
+  TABLE_OUTPUT_FORMATS,
+  outputFormatRefusal,
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-CGOVXSSY.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-LLN7NP3O.js";
+import {
+  linkedinCompaniesRequestSchema
+} from "./chunk-XABVEMC3.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost
+} from "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import {
+  getEnv
+} from "./chunk-G3UCXCC2.js";
+import "./chunk-IWLWY2UD.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/companies.ts
+import { defineCommand } from "citty";
+var COMPANIES_PAGE_SIZE = 100;
+var COMPANIES_TIMEOUT_MS = 18e4;
+var CSV_FIELDS = [
+  "org",
+  "name",
+  "domain",
+  "domainSource",
+  "impressions",
+  "clicks",
+  "engagements",
+  "costLocal",
+  "videoViews",
+  "months",
+  "campaigns"
+];
+function companiesHints(data, request) {
+  const hints = [];
+  if (data.rows.length === 0) {
+    hints.push(
+      `No company shows up for ${data.query.start} to ${data.query.end}${data.query.minImpressions > 0 ? ` at --min-impressions ${data.query.minImpressions}` : ""}. LinkedIn reports companies 12-24h late and leaves out any with fewer than 3 events in a month, so a small or new campaign can have none yet. Try a longer period (--last-months 24), drop --min-impressions, or check the campaigns delivered with \`baker ads linkedin analytics\`.`
+    );
+    return hints;
+  }
+  const withDomain = data.rows.filter((row) => row.domain !== void 0).length;
+  if (withDomain > 0) {
+    hints.push(
+      `${withDomain} companies came back with a website domain \u2014 if HubSpot is connected, \`baker hubspot companies search --domains <domain,domain,\u2026> --with-deals\` (up to 100 per call) shows which are already accounts and which have deals.`
+    );
+  } else if (!request.withDomains && data.rows.length > 0) {
+    hints.push(
+      "Add --with-domains to get each company's website domain, ready for matching against your customer list."
+    );
+  }
+  if (data.totalCompanies > data.rows.length) {
+    const page = data.page ?? 1;
+    const first = (page - 1) * COMPANIES_PAGE_SIZE + 1;
+    const last = first + data.rows.length - 1;
+    const next = last < data.totalCompanies ? ` \u2014 --page ${page + 1} for the next ${COMPANIES_PAGE_SIZE}, ` : " \u2014 ";
+    hints.push(
+      `Showing companies ${first}-${last} of ${data.totalCompanies.toLocaleString("en")}, most engaged first${next}--full for all, or --min-impressions to trim the tail.`
+    );
+  }
+  if (data.query.by === "none" && data.rows.length > 0) {
+    hints.push("--by month shows when each company warmed up; --by campaign shows which campaigns reached it.");
+  }
+  return hints;
+}
+function csvList(raw) {
+  if (typeof raw !== "string") return void 0;
+  const items = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+var FLAG_OF_FIELD = {
+  accountId: "--account-id",
+  campaignIds: "--campaign-id",
+  lastMonths: "--last-months",
+  start: "--start",
+  end: "--end",
+  by: "--by",
+  minImpressions: "--min-impressions",
+  page: "--page"
+};
+function flagOf(field) {
+  return FLAG_OF_FIELD[field.split(".")[0] ?? ""] ?? (field || "args");
+}
+function optionalNumber(raw) {
+  return typeof raw === "string" && raw.trim() !== "" ? Number(raw) : void 0;
+}
+function bareAccountId(raw) {
+  return raw?.startsWith("urn:") ? raw.split(":").pop() : raw;
+}
+var companiesCommand = defineCommand({
+  meta: {
+    name: "companies",
+    description: `Which companies your LinkedIn ads reached \u2014 one row per company over the whole period, most engaged first.
+
+Start here for "which companies are our ads warming", ABM reporting, or building a warm-account list.
+Rows: {org, name, impressions, clicks, engagements, costLocal}. Defaults: the last 12 calendar
+months, the only selected ad account, 100 companies a page (--page 2 for the next, --full for all).
+
+Examples:
+  baker ads linkedin companies                                          # last 12 months, whole account
+  baker ads linkedin companies --page 2                                 # the next 100 companies
+  baker ads linkedin companies --by month --min-impressions 50          # when each company warmed up
+  baker ads linkedin companies --campaign-id 333728193,810055513 --by campaign
+  baker ads linkedin companies --with-domains --output csv              # + website domain, for CRM matching
+  baker ads linkedin companies --last-months 3 --stats                  # + how complete LinkedIn's data is
+
+LinkedIn reports companies 12-24h late and leaves out any company with fewer than 3 events in a month,
+so small companies are undercounted. engagements = LinkedIn's totalEngagements.`
+  },
+  args: {
+    "account-id": {
+      type: "string",
+      description: "Ad account id (numeric or urn:li:sponsoredAccount:N). Default: the only selected account"
+    },
+    "campaign-id": { type: "string", description: "Comma-separated campaign ids \u2014 read only these campaigns" },
+    "last-months": { type: "string", description: "Calendar months back, including this one (1-24, default 12)" },
+    start: { type: "string", description: "Start date YYYY-MM-DD (instead of --last-months)" },
+    end: { type: "string", description: "End date YYYY-MM-DD (default today)" },
+    by: { type: "string", description: "none | month | campaign \u2014 break each company down (default none)" },
+    "with-domains": { type: "boolean", description: "Add each company's website domain and domainSource" },
+    "min-impressions": { type: "string", description: "Leave out companies under N impressions over the period" },
+    full: { type: "boolean", description: "Every company (not just a page of 100), plus videoViews" },
+    page: {
+      type: "string",
+      description: "Which page of 100 companies, most engaged first (default 1); totalCompanies counts them all"
+    },
+    stats: { type: "boolean", description: "Add read-quality stats: row counts, cost/reach/domain coverage" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    const input = {
+      accountId: bareAccountId(args["account-id"] || getEnv().BAKER_LINKEDIN_AD_ACCOUNT_ID),
+      campaignIds: csvList(args["campaign-id"]),
+      lastMonths: optionalNumber(args["last-months"]),
+      start: args.start,
+      end: args.end,
+      by: args.by,
+      withDomains: Boolean(args["with-domains"]),
+      minImpressions: optionalNumber(args["min-impressions"]),
+      full: Boolean(args.full),
+      page: optionalNumber(args.page),
+      stats: Boolean(args.stats),
+      skipCache: Boolean(args["no-cache"])
+    };
+    const parsed = linkedinCompaniesRequestSchema.safeParse(input);
+    const formatRefusal = outputFormatRefusal(csvOrJson(args), TABLE_OUTPUT_FORMATS);
+    if (!parsed.success || formatRefusal !== null) {
+      const issues = parsed.success ? [] : parsed.error.issues;
+      const messages = issues.map((issue) => `${flagOf(issue.path.join("."))}: ${issue.message}`);
+      writeAdsJson({
+        ok: false,
+        error: { code: "INVALID_ARGS", message: [...messages, ...formatRefusal ? [formatRefusal] : []].join("; ") }
+      });
+      process.exit(1);
+    }
+    try {
+      const { data } = await apiPost(
+        "/api/ads/linkedin/companies",
+        input,
+        { timeoutMs: COMPANIES_TIMEOUT_MS }
+      );
+      const hints = companiesHints(data, parsed.data);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        const notes = [...data.warnings.map((w) => `${w.code}: ${w.message}`), ...hints];
+        writeAdsOutput(data.rows, fmt, CSV_FIELDS, notes);
+        return;
+      }
+      writeJsonEnvelope(hints.length > 0 ? { ok: true, data, hints } : { ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+export {
+  companiesCommand,
+  companiesHints
+};
+//# sourceMappingURL=companies-YIKSECXA.js.map