@koda-sl/baker-cli 0.500.0 → 0.503.0

package/dist/insights-EQW34IL4.js

@@ -0,0 +1,437 @@
+import {
+  placementFormatNote,
+  previewFormatForPosition
+} from "./chunk-VIPKDXGU.js";
+import "./chunk-GDFJOCDO.js";
+import {
+  csvOrJson,
+  getDateRange,
+  handleMetaError
+} from "./chunk-B2POVFR2.js";
+import {
+  metaBreakdownSyncedHint,
+  syncedFirstHint
+} from "./chunk-TWKZVPOA.js";
+import "./chunk-Y2JZX6JB.js";
+import {
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-AGBBTTKA.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/insights.ts
+import { defineCommand } from "citty";
+
+// src/commands/ads/meta/placement-delivery.ts
+var MIN_IMPRESSIONS = 20;
+var SILENT_FRACTION_OF_REFERENCE = 0.1;
+var PLAYING_REFERENCE_RATE = 0.5;
+function toNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+function sumActionValues(value) {
+  if (!Array.isArray(value)) return 0;
+  return value.reduce((total, entry) => {
+    const item = entry;
+    return total + toNumber(item?.value);
+  }, 0);
+}
+function aggregate(rows) {
+  const byPlacement = /* @__PURE__ */ new Map();
+  let totalImpressions = 0;
+  for (const row of rows) {
+    const position = row.platform_position;
+    if (typeof position !== "string" || position.length === 0) continue;
+    const platform = typeof row.publisher_platform === "string" ? row.publisher_platform : "";
+    const impressions = toNumber(row.impressions);
+    totalImpressions += impressions;
+    const key = `${platform}/${position}`;
+    const current = byPlacement.get(key) ?? { platform, position, impressions: 0, plays: 0, playRate: 0, share: 0 };
+    current.impressions += impressions;
+    current.plays += sumActionValues(row.video_play_actions);
+    byPlacement.set(key, current);
+  }
+  return [...byPlacement.values()].map((placement) => ({
+    ...placement,
+    playRate: placement.impressions > 0 ? placement.plays / placement.impressions : 0,
+    share: totalImpressions > 0 ? placement.impressions / totalImpressions : 0
+  }));
+}
+function previewCommand(placement) {
+  const format = previewFormatForPosition(placement.position, placement.platform);
+  return format ? `\`baker ads meta preview --creative-id <id> --placement ${placement.position} --platform ${placement.platform}\`` : `no preview format is known for ${placement.position}, so Meta's renderer cannot confirm it \u2014 say the placement is unverified rather than filling the gap`;
+}
+function isSingleAdQuery(rows) {
+  const adIds = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (typeof row.ad_id !== "string" || row.ad_id.length === 0) return false;
+    adIds.add(row.ad_id);
+  }
+  return adIds.size === 1;
+}
+function placementDeliveryHints(rows) {
+  const carriesVideoMetrics = rows.some((row) => Array.isArray(row.video_play_actions));
+  if (!carriesVideoMetrics || !isSingleAdQuery(rows)) return [];
+  const placements = aggregate(rows);
+  const judgeable = placements.filter((p) => p.impressions >= MIN_IMPRESSIONS);
+  const impressions = judgeable.reduce((total, p) => total + p.impressions, 0);
+  const reference = impressions > 0 ? judgeable.reduce((total, p) => total + p.plays, 0) / impressions : 0;
+  if (reference < PLAYING_REFERENCE_RATE) return [];
+  const silent = judgeable.filter((p) => p.playRate < reference * SILENT_FRACTION_OF_REFERENCE).sort((a, b) => b.impressions - a.impressions);
+  if (silent.length === 0) {
+    const worst = [...judgeable].sort((a, b) => a.playRate - b.playRate)[0];
+    return [
+      `Checked every placement above ${MIN_IMPRESSIONS} impressions against this ad's own play rate (${(reference * 100).toFixed(0)}%): no placement is failing to play the video${worst ? `, the lowest being ${worst.platform}/${worst.position} at ${(worst.playRate * 100).toFixed(0)}%` : ""}. So placements do not explain a "it shows as a still image" report \u2014 rule out autoplay off or data saver in the viewer's own app, which renders every video as its cover frame account-wide.`
+    ];
+  }
+  const hints = silent.map((placement) => {
+    const note = placementFormatNote(placement.position);
+    const documented = note ? ` Meta documents this placement: ${note.note}` : "";
+    return `${placement.platform}/${placement.position} delivered ${placement.impressions.toLocaleString("en-US")} impressions (${(placement.share * 100).toFixed(1)}% of the total) and ${placement.plays.toLocaleString("en-US")} video plays \u2014 it may not be rendering the video. This is account evidence, not a rule: confirm what Meta renders there with ${previewCommand(placement)} before you say anything about it.${documented}`;
+  });
+  const combinedShare = silent.reduce((total, placement) => total + placement.share, 0) * 100;
+  hints.push(
+    `Those placements are ${combinedShare.toFixed(1)}% of delivery in this query. State that share before proposing to remove them \u2014 and note that removing placements from a live ad set is a targeting change, which Meta counts as a significant edit that re-enters the learning phase.`
+  );
+  return hints;
+}
+
+// src/commands/ads/meta/presets.ts
+var INSIGHTS_INTENTS = {
+  baseline: {
+    name: "baseline",
+    description: "Spend, impressions, clicks, CTR, CPC, CPM. The default question: 'how is delivery?'",
+    fields: ["impressions", "reach", "frequency", "spend", "clicks", "ctr", "cpc", "cpm"]
+  },
+  revenue: {
+    name: "revenue",
+    description: "Spend, conversions, action_values, purchase_roas. 'How much money are we making?'",
+    fields: ["spend", "actions", "action_values", "conversions", "conversion_values", "purchase_roas"],
+    actionBreakdowns: ["action_type"]
+  },
+  funnel: {
+    name: "funnel",
+    description: "Impression \u2192 click \u2192 landing page \u2192 action. 'Where do users drop off?'",
+    fields: ["impressions", "clicks", "inline_link_clicks", "outbound_clicks", "actions", "spend"],
+    actionBreakdowns: ["action_type"]
+  },
+  ranking: {
+    name: "ranking",
+    description: "Quality, engagement, conversion-rate rankings. 'Which creatives need a refresh?'",
+    fields: ["impressions", "spend", "ctr", "quality_ranking", "engagement_rate_ranking", "conversion_rate_ranking"]
+  },
+  video: {
+    name: "video",
+    description: "Watch funnel, thruplay cost. 'How are video creatives holding attention?'",
+    fields: [
+      "impressions",
+      "spend",
+      "video_play_actions",
+      "video_p25_watched_actions",
+      "video_p50_watched_actions",
+      "video_p75_watched_actions",
+      "video_p100_watched_actions",
+      "video_thruplay_watched_actions",
+      "cost_per_thruplay"
+    ]
+  },
+  identity: {
+    name: "identity",
+    description: "Just the names + spend \u2014 for cheap roll-up summaries.",
+    fields: ["spend", "impressions"]
+  }
+};
+var IDENTITY_FIELDS_BY_LEVEL = {
+  account: ["account_id", "account_name", "account_currency"],
+  campaign: ["campaign_id", "campaign_name", "objective"],
+  adset: ["adset_id", "adset_name", "campaign_id", "campaign_name"],
+  ad: ["ad_id", "ad_name", "adset_id", "adset_name", "campaign_id", "campaign_name"]
+};
+function composeFields(intent, level) {
+  const intentFields = INSIGHTS_INTENTS[intent].fields;
+  const identity = IDENTITY_FIELDS_BY_LEVEL[level];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const f of [...identity, ...intentFields]) {
+    if (!seen.has(f)) {
+      seen.add(f);
+      out.push(f);
+    }
+  }
+  return out;
+}
+function getIntent(name) {
+  return INSIGHTS_INTENTS[name];
+}
+function listIntents() {
+  return Object.values(INSIGHTS_INTENTS);
+}
+
+// src/commands/ads/meta/insights.ts
+var POLL_FIRST_MS = 5e3;
+var POLL_LONGEST_MS = 3e4;
+var POLL_MAX_MS = 10 * 6e4;
+function asyncPollDelayMs(attempt) {
+  return Math.min(Math.round(POLL_FIRST_MS * 1.5 ** attempt), POLL_LONGEST_MS);
+}
+var DEFAULT_ATTRIBUTION_WINDOWS = ["7d_click", "1d_view"];
+var DEFAULT_FILTERING = [{ field: "impressions", operator: "GREATER_THAN", value: 0 }];
+function commaSplit(input) {
+  if (!input) return void 0;
+  return input.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parseFiltering(raw) {
+  if (!raw) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    handleMetaError(new Error("Invalid --filtering JSON"));
+  }
+}
+function pickIntent(name) {
+  if (!name) return "baseline";
+  const found = getIntent(name);
+  if (!found) {
+    handleMetaError(new Error(`Unknown --intent: ${name}. Use --list-intents to see options.`));
+  }
+  return found.name;
+}
+function pickLevel(args) {
+  const raw = args.level;
+  if (!raw) return "account";
+  if (raw !== "account" && raw !== "campaign" && raw !== "adset" && raw !== "ad") {
+    handleMetaError(new Error("--level must be one of: account|campaign|adset|ad"));
+  }
+  return raw;
+}
+function shouldAutoAsync(body) {
+  const breakdownCount = (body.breakdowns ?? []).length;
+  if (body.level === "ad" && breakdownCount > 0 && body.object.startsWith("act_")) {
+    return true;
+  }
+  if (breakdownCount > 2) {
+    return true;
+  }
+  if (body.since && body.until) {
+    const days = (Date.parse(body.until) - Date.parse(body.since)) / 864e5;
+    if (days > 90) {
+      return true;
+    }
+  }
+  return false;
+}
+function wantsAsync(asyncFlag, body) {
+  if (asyncFlag === true) return true;
+  if (asyncFlag === false) return false;
+  return shouldAutoAsync(body);
+}
+function applyDateRange(body, args) {
+  const range = getDateRange(args);
+  if (range.datePreset) body.datePreset = range.datePreset;
+  if (range.since) body.since = range.since;
+  if (range.until) body.until = range.until;
+  if (!body.datePreset && !(body.since && body.until)) {
+    body.datePreset = "last_7d";
+  }
+}
+function buildFiltering(args) {
+  const explicit = parseFiltering(args.filtering);
+  if (explicit) return explicit;
+  if (args["include-undelivered"]) return void 0;
+  return DEFAULT_FILTERING;
+}
+function buildAttributionWindows(args) {
+  const explicit = commaSplit(args["attribution-windows"]);
+  if (explicit) return explicit;
+  return DEFAULT_ATTRIBUTION_WINDOWS;
+}
+function buildBody(args) {
+  const intent = pickIntent(args.intent);
+  const level = pickLevel(args);
+  const intentDef = getIntent(intent);
+  const explicitFields = commaSplit(args.fields);
+  const fields = explicitFields ?? composeFields(intent, level);
+  const breakdowns = commaSplit(args.breakdowns);
+  const actionBreakdowns = commaSplit(args["action-breakdowns"]) ?? intentDef?.actionBreakdowns;
+  const body = {
+    object: args.object,
+    level,
+    fields,
+    timeIncrement: args["time-increment"],
+    breakdowns,
+    actionBreakdowns,
+    filtering: buildFiltering(args),
+    attributionWindows: buildAttributionWindows(args),
+    useAccountAttributionSetting: Boolean(args["use-account-attribution"]),
+    useUnifiedAttributionSetting: Boolean(args["use-unified-attribution"]),
+    limit: args.limit ? Number(args.limit) : 1e3,
+    skipCache: Boolean(args["no-cache"])
+  };
+  applyDateRange(body, args);
+  return body;
+}
+async function pollAsync(reportRunId) {
+  const start = Date.now();
+  for (let attempt = 0; Date.now() - start < POLL_MAX_MS; attempt++) {
+    const status = await apiGet(
+      "/api/ads/meta/insights/async/status",
+      { "report-run-id": reportRunId }
+    );
+    if (status.async_status === "Job Completed") return;
+    if (status.async_status === "Job Failed" || status.async_status === "Job Skipped") {
+      handleMetaError(new Error(`Async insights job ${status.async_status}`));
+    }
+    process.stderr.write(
+      `Async insights ${status.async_status ?? "queued"} (${Math.round(status.async_percent_completion ?? 0)}%)\u2026
+`
+    );
+    await new Promise((resolve) => setTimeout(resolve, asyncPollDelayMs(attempt)));
+  }
+  handleMetaError(new Error("Async insights polling timed out after 10 minutes"));
+}
+async function runAsync(body) {
+  const submit = await apiPost("/api/ads/meta/insights/async", body);
+  process.stderr.write(`Async insights job: ${submit.reportRunId}
+`);
+  await pollAsync(submit.reportRunId);
+  return apiPost("/api/ads/meta/insights/async/result", {
+    reportRunId: submit.reportRunId,
+    fields: body.fields,
+    limit: body.limit
+  });
+}
+function sortRowsBySpendDesc(rows) {
+  return [...rows].sort((a, b) => {
+    const sa = Number(a.spend ?? 0);
+    const sb = Number(b.spend ?? 0);
+    if (Number.isNaN(sa) || Number.isNaN(sb)) return 0;
+    return sb - sa;
+  });
+}
+function syncedHintOf(body) {
+  const breakdowns = body.breakdowns ?? [];
+  if (breakdowns.length > 0) return metaBreakdownSyncedHint(breakdowns);
+  const level = body.level === "adset" ? "ad_group" : body.level;
+  return syncedFirstHint("meta", level);
+}
+var insightsCommand = defineCommand({
+  meta: {
+    name: "insights",
+    description: `Performance reporting \u2014 the main Meta tool for AI agents.
+
+Smart defaults so the AI doesn't have to remember every flag:
+  --level account                       (set --level campaign|adset|ad to drill in)
+  --intent baseline                     (or revenue|funnel|ranking|video|identity)
+  --date-preset last_7d                 (override with --since/--until)
+  --attribution-windows 7d_click,1d_view  (the only ones still working post Jan 2026)
+  filter: impressions > 0               (skip undelivered rows; --include-undelivered to keep)
+  sort: spend descending                (when result fits in memory)
+  auto-async when query is heavy (level=ad + breakdowns, big date ranges, etc.)
+
+Identity fields (campaign_name, ad_name etc.) are appended automatically based on --level so rows
+are self-describing.
+
+Examples \u2014 common AI questions:
+  # "How is GreenLeaf doing this week?"
+  baker ads meta insights --object act_123
+
+  # "Which campaigns are profitable?"
+  baker ads meta insights --object act_123 --level campaign --intent revenue --date-preset last_28d
+
+  # "Which creatives need a refresh?"
+  baker ads meta insights --object act_123 --level ad --intent ranking --date-preset last_14d
+
+  # "Where do users drop off the funnel?"
+  baker ads meta insights --object act_123 --intent funnel
+
+  # "Should we shift budget to Instagram?"
+  baker ads meta insights --object act_123 --level adset --breakdowns publisher_platform,platform_position
+
+  # Custom field set (escape hatch)
+  baker ads meta insights --object act_123 --fields impressions,spend,actions
+
+Async is automatic for heavy queries; pass --async to force it, or --no-async to refuse fallback.`
+  },
+  args: {
+    object: {
+      type: "string",
+      description: "Object ID \u2014 act_<id> for account, or a campaign/adset/ad ID"
+    },
+    level: { type: "string", description: "account|campaign|adset|ad (default: account)" },
+    intent: { type: "string", description: "baseline|revenue|funnel|ranking|video|identity (default: baseline)" },
+    fields: { type: "string", description: "Comma-separated field list (overrides --intent bundle)" },
+    "list-intents": { type: "boolean", description: "Print available intents and exit" },
+    "date-preset": { type: "string", description: "Meta date preset (last_7d, last_28d, today, ...)" },
+    since: { type: "string", description: "Custom start date YYYY-MM-DD" },
+    until: { type: "string", description: "Custom end date YYYY-MM-DD" },
+    "time-increment": { type: "string", description: "1 (day) | monthly | all_days" },
+    breakdowns: { type: "string", description: "Comma-separated breakdowns (e.g. publisher_platform,age)" },
+    "action-breakdowns": {
+      type: "string",
+      description: "Slice the actions[] array (default: action_type for revenue/funnel)"
+    },
+    filtering: { type: "string", description: "Override default filter \u2014 JSON array of {field,operator,value}" },
+    "include-undelivered": { type: "boolean", description: "Keep rows where impressions=0 (off by default)" },
+    "attribution-windows": {
+      type: "string",
+      description: "Override default 7d_click,1d_view (only 1d_view, 1d_click, 7d_click, 28d_click work post Jan 2026)"
+    },
+    "use-account-attribution": { type: "boolean", description: "Use account-saved attribution setting" },
+    "use-unified-attribution": { type: "boolean", description: "Use ad-set unified attribution setting" },
+    limit: { type: "string", description: "Max rows (default 1000)" },
+    // Declaring `no-async` too would be a trap: citty resolves it to `async: false`
+    // and never fills an arg of that name, so the declaration reads as supported
+    // while nothing consumes it.
+    async: { type: "boolean", description: "Force the async submit-and-poll path (--no-async refuses it)" },
+    "no-sort": { type: "boolean", description: "Skip default spend-desc sort" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "Output format", default: "json" }
+  },
+  run: async ({ args }) => {
+    if (args["list-intents"]) {
+      writeAdsJson({ ok: true, data: listIntents() });
+      return;
+    }
+    if (!args.object) {
+      writeAdsJson({
+        ok: false,
+        error: { code: "VALIDATION_ERROR", message: "Missing required argument: --object" }
+      });
+      process.exit(1);
+    }
+    const body = buildBody(args);
+    const fmt = csvOrJson(args);
+    const wantAsync = wantsAsync(args.async, body);
+    try {
+      const rows = wantAsync ? await runAsync(body) : await apiPost("/api/ads/meta/insights", body);
+      const sorted = args["no-sort"] ? rows : sortRowsBySpendDesc(rows);
+      if (fmt !== "json") {
+        writeAdsOutput(sorted, fmt, body.fields);
+        return;
+      }
+      const synced = syncedHintOf(body);
+      const hints = [...placementDeliveryHints(sorted), ...synced === null ? [] : [synced]];
+      writeJsonEnvelope({ ok: true, data: sorted, hints });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+export {
+  asyncPollDelayMs,
+  insightsCommand,
+  wantsAsync
+};
+//# sourceMappingURL=insights-EQW34IL4.js.map

package/dist/insights-JZVXC7IJ.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-M7HD42M6.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-JZVXC7IJ.js.map