@koda-sl/baker-cli 0.469.0-dev.42f26270e → 0.470.0-dev.fb31086c9

package/dist/brief-CNXT5COV.js

@@ -0,0 +1,490 @@
+import {
+  buildNext,
+  ideasReport
+} from "./chunk-PO6PPSE5.js";
+import {
+  withDefinitions
+} from "./chunk-RGLTV4X7.js";
+import {
+  liveViewerLookups,
+  marketQuery
+} from "./chunk-ZEFHDG3Q.js";
+import {
+  buildSearchBody
+} from "./chunk-CVC4G2XV.js";
+import "./chunk-WK5UROGJ.js";
+import "./chunk-Y6ER23FQ.js";
+import {
+  AWARENESS_STAGES,
+  IDEA_ANGLES,
+  IDEA_FORMATS,
+  readInsights
+} from "./chunk-6RFRIPYE.js";
+import {
+  researchCustomers
+} from "./chunk-JBKFGD4J.js";
+import "./chunk-DSYBL7MK.js";
+import "./chunk-LYPYD2W5.js";
+import "./chunk-YWQTXMP5.js";
+import "./chunk-NFSLRRIE.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-5BMPVG43.js";
+import "./chunk-KOMLRHVH.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-M22GYDBE.js";
+import "./chunk-MSK6W4HG.js";
+import "./chunk-CAMX6OHF.js";
+import "./chunk-WLCPTR3B.js";
+import {
+  viewerFromKnowledge
+} from "./chunk-5HYSKH77.js";
+import "./chunk-KIGGMKAE.js";
+import "./chunk-JVRA7EGL.js";
+import "./chunk-3BLSLGVH.js";
+import "./chunk-B3C5RXM4.js";
+import "./chunk-KLVHEGSW.js";
+import "./chunk-2NCDN7ZT.js";
+import "./chunk-RPJYEJDQ.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-I2DNBEV6.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-AGIX3HNF.js";
+import "./chunk-NY3LDKO4.js";
+import {
+  getEnv
+} from "./chunk-PBI5PQEZ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-MV3PVKTU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/brief.ts
+import { readFileSync } from "fs";
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+
+// src/commands/creatives/brief-model.ts
+var MIN_IMPRESSIONS = 1e3;
+var LOW_CTR = 1.5;
+var LOW_CVR = 1;
+var round = (n) => Math.round(n * 100) / 100;
+function diagnoseBottleneck(totals) {
+  const ctr = totals.impressions > 0 ? round(totals.linkClicks / totals.impressions * 100) : null;
+  const cvr = totals.linkClicks > 0 ? round(totals.results / totals.linkClicks * 100) : null;
+  if (totals.impressions < MIN_IMPRESSIONS || ctr === null) {
+    return { verdict: "too_little_data", ctr, cvr, why: "Too little delivery in the last 30 days to call it." };
+  }
+  if (ctr < LOW_CTR) {
+    return {
+      verdict: "hook",
+      ctr,
+      cvr,
+      why: `Link click-through ${ctr}% (under ${LOW_CTR}%): people scroll past. New ideas and hooks are the fix.`
+    };
+  }
+  if (cvr !== null && cvr < LOW_CVR) {
+    return {
+      verdict: "after_click",
+      ctr,
+      cvr,
+      why: `People click (${ctr}%) but only ${cvr}% act: the page or the offer loses them, and a new ad will not fix that. Say so, make the ads' promise match the page, and make one idea an offer idea.`
+    };
+  }
+  return {
+    verdict: "none",
+    ctr,
+    cvr,
+    why: `Click-through ${ctr}% and ${cvr ?? 0}% of clicks act: the ads work. Build on the winners first.`
+  };
+}
+var CONVERSION_ACTION = /^(lead|purchase|complete_registration|submit_application|schedule|contact|start_trial|subscribe|offsite_conversion\.|onsite_conversion\.lead|onsite_web_lead|omni_purchase|omni_complete_registration)/;
+function resultsOf(actions) {
+  if (!Array.isArray(actions)) return 0;
+  let total = 0;
+  for (const action of actions) {
+    const type = action?.action_type;
+    const value = Number(action?.value ?? 0);
+    if (typeof type === "string" && CONVERSION_ACTION.test(type) && Number.isFinite(value)) total += value;
+  }
+  return total;
+}
+var MIN_OBSERVED = 5;
+var MAX_QUOTES = 6;
+function customerTruth(insights) {
+  const byType = {};
+  for (const insight of insights) byType[insight.type] = (byType[insight.type] ?? 0) + 1;
+  const observed = insights.filter((i) => i.status === "observed");
+  const seen = /* @__PURE__ */ new Set();
+  const quotes = [];
+  for (const insight of observed) {
+    if (seen.has(insight.type) || quotes.length >= MAX_QUOTES) continue;
+    seen.add(insight.type);
+    quotes.push({
+      id: insight.id,
+      type: insight.type,
+      quote: insight.quote.length > 140 ? `${insight.quote.slice(0, 137)}...` : insight.quote
+    });
+  }
+  return { total: insights.length, observed: observed.length, thin: observed.length < MIN_OBSERVED, byType, quotes };
+}
+var MAX_SAYING = 6;
+var KEPT_STAGES = /* @__PURE__ */ new Set(["proven", "evergreen"]);
+function keptAfterTesting(ad) {
+  return ad.survived_test === true || KEPT_STAGES.has(ad.stage ?? "");
+}
+var SAME_ANGLE = 0.4;
+function angleWords(angle) {
+  return new Set(
+    angle.toLowerCase().split(/[^\p{L}]+/u).filter((w) => w.length >= 4 && w !== "your" && w !== "with").map((w) => w.replace(/s$/, ""))
+  );
+}
+function overlap(a, b) {
+  const shared = [...a].filter((w) => b.has(w)).length;
+  const all = (/* @__PURE__ */ new Set([...a, ...b])).size;
+  return all === 0 ? 0 : shared / all;
+}
+function tally(values) {
+  const counts = {};
+  for (const value of values) if (value) counts[value] = (counts[value] ?? 0) + 1;
+  return counts;
+}
+function marketMap(ads, source) {
+  const groups = [];
+  for (const ad of ads) {
+    const angle = ad.dna.angle?.trim();
+    if (!angle) continue;
+    const words = angleWords(angle);
+    const brand = ad.advertiser ?? "?";
+    let group = groups.find((g) => overlap(g.words, words) >= SAME_ANGLE);
+    if (!group) {
+      group = { angle, words, brands: /* @__PURE__ */ new Set(), kept: /* @__PURE__ */ new Set() };
+      groups.push(group);
+    }
+    group.brands.add(brand);
+    if (keptAfterTesting(ad)) group.kept.add(brand);
+  }
+  const saying = groups.map((g) => ({ angle: g.angle, brands: g.brands.size, ...g.kept.size > 0 ? { kept_brands: g.kept.size } : {} })).sort((a, b) => (b.kept_brands ?? 0) - (a.kept_brands ?? 0) || b.brands - a.brands).slice(0, MAX_SAYING);
+  const keptAds = ads.filter(keptAfterTesting).length;
+  const stages = tally(ads.map((a) => a.dna.sophistication_stage));
+  const sophistication = Object.entries(stages).sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
+  const awareness = tally(ads.map((a) => a.dna.awareness_stage));
+  return {
+    source,
+    ads: ads.length,
+    brands: new Set(ads.map((a) => a.advertiser ?? "?")).size,
+    sophistication,
+    saying,
+    awareness,
+    containers: tally(ads.map((a) => a.dna.container)),
+    unspoken: AWARENESS_STAGES.filter((stage) => !awareness[stage]),
+    ...keptAds > 0 ? { kept_ads: keptAds } : {}
+  };
+}
+
+// src/commands/creatives/brief.ts
+var DESCRIPTION = `Start here before making ads: one read of everything that decides what to make. Who sees the ads, what already works in the account and where it loses people (a verdict, not raw numbers), what this company's reviewers approved and rejected, what customers said in their own words, and the ideas already on file.
+
+  baker creatives brief                         # the viewer from the Knowledge
+  baker creatives brief --adset <id>            # the viewer that ad set reaches
+  baker creatives brief --account-id act_<id>   # when more than one Meta account is connected
+
+Then write 4-8 ideas in src/creatives/_ideas/ and run \`baker creatives ideas\`. With few customer quotes on file it gathers them itself first (\`baker research customers\`, about 30 s; --no-research to skip).`;
+var ARGS = {
+  adset: {
+    type: "string",
+    description: "The Meta ad set the ads are for: its viewer replaces the Knowledge's",
+    required: false
+  },
+  "account-id": {
+    type: "string",
+    description: "Meta ad account to read (act_<id>); default: the one connected account",
+    required: false
+  },
+  full: {
+    type: "boolean",
+    description: "Every quote, idea and creative instead of the top few",
+    required: false,
+    default: false
+  },
+  research: {
+    type: "boolean",
+    description: "Gather customer quotes first when few are on file (default true; --no-research skips it)",
+    required: false,
+    default: true
+  }
+};
+registerSchema({ command: "creatives.brief", description: DESCRIPTION, args: ARGS });
+var unavailable = (err) => ({
+  unavailable: err instanceof Error ? err.message.slice(0, 200) : "could not be read"
+});
+async function section(read) {
+  try {
+    return await read();
+  } catch (err) {
+    return unavailable(err);
+  }
+}
+function isAvailable(value) {
+  return !(value !== null && typeof value === "object" && "unavailable" in value);
+}
+async function companyStatus(root) {
+  const doc = await readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => "");
+  return doc.trim() && !/^#\s*Company\s*\n+\s*TODO/m.test(doc) ? "ready" : "missing";
+}
+async function readOffers(root) {
+  const dir = path.join(root, "src", "content", "offers");
+  const files = (await readdir(dir, { recursive: true }).catch(() => [])).filter(
+    (f) => f.endsWith(".md")
+  );
+  return files.map((f) => f.replace(/\.md$/, "")).sort();
+}
+function readDefinition(root, slug) {
+  try {
+    return readFileSync(path.join(root, "src", "creatives", slug, "_definition.md"), "utf8");
+  } catch {
+    return null;
+  }
+}
+async function readViewer(root, adSet) {
+  const lookups = liveViewerLookups(root);
+  if (adSet) {
+    const read = await lookups.adSetViewer(adSet).catch(() => null);
+    if (read) return read;
+  }
+  const personas = await lookups.personas().catch(() => []);
+  return viewerFromKnowledge({ personas: personas.map((p) => p.segment ?? p.title ?? p.slug) });
+}
+var MARKET_ADS = 40;
+var MARKET_FALLBACK_ADS = 15;
+var MARKET_SEARCH_MS = 12e3;
+async function readMarket(root) {
+  const query = marketQuery(await readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => ""));
+  if (!query) return null;
+  const search = (body) => apiPost("/api/ad-library/winners/search", body, {
+    timeoutMs: MARKET_SEARCH_MS
+  }).catch((err) => {
+    if (err instanceof ApiError && err.code === "TIMEOUT") {
+      throw new Error("the ad library did not answer in time, so competitors' claims are left out");
+    }
+    throw err;
+  });
+  const [followed, all] = await Promise.allSettled([
+    search(buildSearchBody({ scope: "followed", platform: "meta", limit: MARKET_ADS, maxPerAdvertiser: 8 })),
+    search(buildSearchBody({ query, scope: "all", platform: "meta", limit: MARKET_FALLBACK_ADS, maxPerAdvertiser: 3 }))
+  ]);
+  if (followed.status === "fulfilled" && followed.value.results.length > 0)
+    return marketMap(followed.value.results, "followed");
+  if (all.status === "rejected") throw all.reason;
+  return all.value.results.length > 0 ? marketMap(all.value.results, "library") : null;
+}
+async function metaAccountId(given) {
+  if (given) return given.startsWith("act_") ? given : `act_${given}`;
+  const named = getEnv().BAKER_META_AD_ACCOUNT_ID;
+  if (named) return `act_${named.replace(/^act_/, "")}`;
+  const accounts = await apiGet("/api/ads/meta/accounts");
+  const ids = accounts.flatMap((a) => {
+    const id2 = a.externalId ?? a.id;
+    return typeof id2 === "string" && id2 ? [id2] : [];
+  });
+  if (ids.length !== 1) return null;
+  const id = ids[0];
+  return id.startsWith("act_") ? id : `act_${id}`;
+}
+async function readBottleneck(accountId) {
+  const rows = await apiPost("/api/ads/meta/insights", {
+    object: accountId,
+    level: "account",
+    fields: ["impressions", "inline_link_clicks", "actions", "spend"],
+    actionBreakdowns: ["action_type"],
+    datePreset: "last_30d",
+    limit: 10
+  });
+  const totals = { impressions: 0, linkClicks: 0, results: 0 };
+  for (const row of rows) {
+    totals.impressions += Number(row.impressions ?? 0);
+    totals.linkClicks += Number(row.inline_link_clicks ?? 0);
+    totals.results += resultsOf(row.actions);
+  }
+  return diagnoseBottleneck(totals);
+}
+function leanCreative(c) {
+  return {
+    creative: c.slug ?? c.title,
+    costPerResult: c.costPerResult,
+    ...c.currency ? { currency: c.currency } : {},
+    ctr: c.ctr,
+    fatigue: c.fatigue,
+    ...c.definition?.idea ? { idea: c.definition.idea } : {},
+    ...c.definition?.angle ? { angle: c.definition.angle } : {}
+  };
+}
+function whatWorks(creatives, limit = 3) {
+  const priced = creatives.filter((c) => c.costPerResult !== null && c.costPerResult > 0);
+  const best = [...priced].sort((a, b) => (a.costPerResult ?? 0) - (b.costPerResult ?? 0)).slice(0, limit);
+  const tired = creatives.filter((c) => c.fatigue === "fatigued" || c.fatigue === "dead");
+  return { best: best.map(leanCreative), replace: tired.map(leanCreative) };
+}
+var HEARD_IT_ALL = /^s[345]/;
+function customersHint(parts) {
+  if (parts.researched) {
+    return parts.researched.written > 0 ? `${parts.researched.written} customer quotes were just gathered from reviews and Reddit and are in \`customers\`: cite them by id in each idea's \`evidence\`.` : "Customer research found nothing to keep: ideas go in as explore bets (an empty `evidence` list). Never research customers again in this turn.";
+  }
+  if (!parts.customers.thin) return null;
+  return `Only ${parts.customers.observed} customer quotes on file: run \`baker research customers\` now, before writing ideas, so they stand on what customers said. It gathers reviews, Reddit and the web and writes the quotes with their sources in about a minute; never a subagent or web searches of your own for this.`;
+}
+function briefHints(parts) {
+  const hints = [];
+  if (parts.company === "missing") {
+    hints.push("COMPANY.md is empty: run /company-discovery first, or every idea is a guess about the business.");
+  }
+  const customers = customersHint(parts);
+  if (customers) hints.push(customers);
+  if (parts.bottleneck && isAvailable(parts.bottleneck) && parts.bottleneck.verdict === "after_click") {
+    hints.push("The account loses people after the click: tell the person, and make one idea an offer idea.");
+  }
+  if (parts.market?.sophistication && HEARD_IT_ALL.test(parts.market.sophistication)) {
+    hints.push(
+      `This market has heard the plain claim (sophistication ${parts.market.sophistication}): lead with how it works (a mechanism), proof, or an angle nobody uses, never a bigger claim.`
+    );
+  }
+  const claims = parts.market?.saying.map(
+    (s) => s.kept_brands ? `"${s.angle}" (kept after testing by ${s.kept_brands})` : `"${s.angle}"`
+  ) ?? [];
+  if (claims.length > 0) {
+    hints.push(
+      `Competitors already say ${claims.join(", ")}. A message one of them could also run is not a new idea, however it is worded: say what only we have (the offer, a proof, a customer's words) or how it works.`
+    );
+  }
+  for (const won of parts.learned.winners) {
+    hints.push(
+      `${won.idea} won in the account ("${won.message}"): build on it first, the same message in a new format or for a new persona.`
+    );
+  }
+  if (parts.learned.failed.length > 0) {
+    const lost = parts.learned.failed.map((f) => `"${f.message}"`).join(", ");
+    hints.push(`Never repeat a message that lost in the account: ${lost}.`);
+  }
+  if (parts.rejected > parts.approved && parts.rejected > 0) {
+    hints.push("Reviewers rejected more than they approved: read topRejectionReasons and avoid them in every idea.");
+  }
+  if (parts.buildNext.length > 0) {
+    hints.push(`Ideas ready to build: ${parts.buildNext.join(", ")} (\`baker creatives make <idea>\`).`);
+  } else {
+    hints.push(
+      `Write 4-8 ideas in src/creatives/_ideas/<idea>.md (who, message, evidence, awareness, angle, format, job, why), then \`baker creatives ideas\`. awareness: ${AWARENESS_STAGES.join(" | ")}. angle: ${IDEA_ANGLES.join(", ")}. format: ${IDEA_FORMATS.join(", ")}.`
+    );
+  }
+  return hints;
+}
+async function readBrief(root, args) {
+  const account = metaAccountId(args.accountId).catch(() => null);
+  const [company, offers, viewer, insights, ideas, performance, feedback, accountId, bottleneck, market] = await Promise.all([
+    companyStatus(root),
+    readOffers(root),
+    readViewer(root, args.adset),
+    readInsights(root),
+    ideasReport(root),
+    section(
+      async () => withDefinitions(
+        await apiPost("/api/creatives/performance", {}),
+        (slug) => readDefinition(root, slug)
+      )
+    ),
+    section(() => apiPost("/api/creatives/feedback", {})),
+    account,
+    account.then((id) => id ? section(() => readBottleneck(id)) : null),
+    section(() => readMarket(root))
+  ]);
+  return { company, offers, viewer, insights, ideas, performance, feedback, accountId, bottleneck, market };
+}
+function accountPart(brief, full) {
+  if (!brief.accountId) {
+    return { unavailable: "no single Meta ad account connected: pass --account-id act_<id>, or work from customers" };
+  }
+  const works = isAvailable(brief.performance) ? whatWorks(brief.performance.data.creatives, full ? 10 : 3) : { creatives: brief.performance };
+  return { id: brief.accountId, bottleneck: brief.bottleneck, ...works };
+}
+function marketPart(market, full) {
+  if (!isAvailable(market)) return market;
+  if (!market) return { unavailable: "no library ads match what COMPANY.md says the company sells" };
+  if (full) return market;
+  const { containers: _containers, ...lean } = market;
+  return lean;
+}
+function briefEnvelope(brief, full, researched) {
+  const customers = customerTruth(brief.insights);
+  const summary = isAvailable(brief.feedback) ? brief.feedback.data.summary : null;
+  const next = buildNext(brief.ideas.ideas);
+  const toBuild = brief.ideas.ideas.filter((i) => i.status === "idea").length;
+  const withStatus = (status) => brief.ideas.ideas.filter((i) => i.status === status).map((i) => ({ idea: i.id, message: i.message }));
+  const learned = { winners: withStatus("winner"), failed: withStatus("failed") };
+  return {
+    ok: true,
+    data: {
+      company: brief.company,
+      viewer: { temperature: brief.viewer.temperature, knows: brief.viewer.knows, source: brief.viewer.source },
+      offers: brief.offers,
+      account: accountPart(brief, full),
+      taste: summary ? {
+        approved: summary.approved,
+        rejected: summary.rejected,
+        topRejectionReasons: summary.topRejectionReasons.slice(0, 3).map((r) => r.label)
+      } : brief.feedback,
+      customers: full ? { ...customers, quotes: brief.insights.map((i) => ({ id: i.id, type: i.type, quote: i.quote })) } : customers,
+      market: marketPart(brief.market, full),
+      ideas: {
+        to_build: toBuild,
+        built: brief.ideas.ideas.length - toBuild,
+        build_next: next,
+        ...learned.winners.length > 0 ? { winners: learned.winners } : {},
+        ...learned.failed.length > 0 ? { failed: learned.failed } : {}
+      }
+    },
+    hints: briefHints({
+      company: brief.company,
+      customers,
+      bottleneck: brief.bottleneck,
+      ideasToBuild: toBuild,
+      buildNext: next,
+      approved: summary?.approved ?? 0,
+      rejected: summary?.rejected ?? 0,
+      market: isAvailable(brief.market) ? brief.market : null,
+      learned,
+      ...researched ? { researched } : {}
+    })
+  };
+}
+var briefCommand = defineCommand({
+  meta: { name: "brief", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const full = args.full === true;
+    const thin = args.research !== false && customerTruth(await readInsights(root)).thin;
+    const research = thin ? researchCustomers(root, {}).catch(() => null) : null;
+    const brief = await readBrief(root, {
+      ...typeof args.adset === "string" && args.adset ? { adset: args.adset } : {},
+      ...typeof args["account-id"] === "string" && args["account-id"] ? { accountId: args["account-id"] } : {},
+      full
+    });
+    const found = research ? await research : null;
+    const written = found?.shown.length ?? 0;
+    const insights = written > 0 ? await readInsights(root) : brief.insights;
+    writeJson(briefEnvelope({ ...brief, insights }, full, research ? { written } : void 0));
+  }
+});
+export {
+  briefCommand,
+  briefEnvelope,
+  briefHints,
+  whatWorks
+};
+//# sourceMappingURL=brief-CNXT5COV.js.map

package/dist/businesses-ZNYF4BBK.js

@@ -0,0 +1,53 @@
+import {
+  csvOrJson,
+  handleMetaError
+} from "./chunk-XKJNDYD3.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-G3TL63X5.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-M5G6QOR4.js";
+import {
+  apiGet
+} from "./chunk-AGIX3HNF.js";
+import "./chunk-NY3LDKO4.js";
+import "./chunk-PBI5PQEZ.js";
+import "./chunk-MV3PVKTU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/businesses.ts
+import { defineCommand } from "citty";
+var businessesCommand = defineCommand({
+  meta: {
+    name: "businesses",
+    description: `List Meta Business Manager accounts linked to this company's selected ad accounts. Required for ad-studies and product-catalogs commands.
+
+Examples:
+  baker ads meta businesses`
+  },
+  args: {
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "Output format", default: "json" }
+  },
+  run: async ({ args }) => {
+    try {
+      const params = {};
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/meta/businesses", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+export {
+  businessesCommand
+};
+//# sourceMappingURL=businesses-ZNYF4BBK.js.map

package/dist/campaign-groups-VBRRZI7L.js

@@ -0,0 +1,95 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg,
+  resolveStatusFilter,
+  statusesArgDescription
+} from "./chunk-NHFX7CBM.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-G3TL63X5.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-M5G6QOR4.js";
+import "./chunk-RPJYEJDQ.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-I2DNBEV6.js";
+import {
+  apiGet
+} from "./chunk-AGIX3HNF.js";
+import "./chunk-NY3LDKO4.js";
+import "./chunk-PBI5PQEZ.js";
+import "./chunk-MV3PVKTU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/campaign-groups.ts
+import { defineCommand } from "citty";
+var listArgs = {
+  "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+  "account-urn": { type: "string", description: "Alias for --account-id" },
+  "all-statuses": { type: "boolean", description: "Drop the default ACTIVE filter" },
+  statuses: { type: "string", description: statusesArgDescription("campaignGroups") },
+  limit: { type: "string", description: "Max rows (default: 500)" },
+  "no-cache": NO_CACHE_ARG,
+  output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+};
+var campaignGroupsListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List LinkedIn campaign groups. Runs by default when no subcommand is given."
+  },
+  args: listArgs,
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      const statuses = resolveStatusFilter(args, "campaignGroups");
+      if (statuses) params.statuses = statuses.join(",");
+      if (args.limit) params.limit = String(args.limit);
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/campaign-groups", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var campaignGroupsCommand = defineCommand({
+  meta: {
+    name: "campaign-groups",
+    description: `List LinkedIn campaign groups, or stage writes (create/update/pause/resume/duplicate).
+
+Default: ACTIVE only. Pass --all-statuses to widen, or --statuses ACTIVE,PAUSED to override.
+Write subcommands stage ops on this chat's draft and apply only when the chat is published.
+
+Examples:
+  baker ads linkedin campaign-groups --account-id 503001492
+  baker ads linkedin campaign-groups --account-id 503001492 --all-statuses
+  baker ads linkedin campaign-groups create --name "Q3 ABM" --start 2026-07-10 --total-budget 5000 --currency EUR`
+  },
+  subCommands: {
+    list: campaignGroupsListCommand,
+    create: () => import("./write-commands-D5X6N7Q4.js").then((m) => m.campaignGroupsCreateCommand),
+    update: () => import("./write-commands-D5X6N7Q4.js").then((m) => m.campaignGroupsUpdateCommand),
+    pause: () => import("./write-commands-D5X6N7Q4.js").then((m) => m.campaignGroupsPauseCommand),
+    resume: () => import("./write-commands-D5X6N7Q4.js").then((m) => m.campaignGroupsResumeCommand),
+    duplicate: () => import("./write-commands-D5X6N7Q4.js").then((m) => m.campaignGroupsDuplicateCommand)
+  },
+  // A parent must never declare `run`: citty falls through to it *after* running
+  // the matched subcommand, so every write would also trigger a full live list.
+  // `args` stays here so citty's subcommand scan knows which flags take a value.
+  args: listArgs,
+  default: "list"
+});
+export {
+  campaignGroupsCommand
+};
+//# sourceMappingURL=campaign-groups-VBRRZI7L.js.map