@koda-sl/baker-cli 0.493.0 → 0.495.0-dev.6b9c22aff

package/dist/flows-DMMCSBWY.js

@@ -0,0 +1,247 @@
+import {
+  collectConfigStatus,
+  collectSideEffects,
+  listFlowSlugs,
+  readFlowTree,
+  readSettings,
+  redactTree,
+  requestFlowInputCall,
+  withSettings
+} from "./chunk-74BP3JIV.js";
+import {
+  FLOW_AGENT_DESTINATION_KINDS,
+  driftRepairHint,
+  flowNodeTriggers
+} from "./chunk-JGM4WGC2.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-NAA4CKZZ.js";
+import {
+  apiPost
+} from "./chunk-6YLNY6CK.js";
+import "./chunk-D5NEIESR.js";
+import "./chunk-57KKVDDR.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-QANGHND7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/index.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "flows.list",
+  description: "List the Forms (flows) in this workspace and how many confidential fields each still needs configured. Read-only.",
+  args: {}
+});
+registerSchema({
+  command: "flows.show",
+  description: "Show a Form's confidential fields and whether each is configured (secrets/connections/third-party resources), AND whether its destination has changed under it \u2014 never reveals secret values. Destination drift is the one problem a Form cannot show you itself: when a HubSpot field a Form maps is deleted, HubSpot refuses the WHOLE submission and the visitor still sees the thank-you screen, so every lead is lost silently. Run this before changing any Form. Each sealed destination says where it sends (recipients, subject, sheet) \u2014 never a credential. Author structure by editing the flow's _data.json; set destinations yourself with `baker flows connect` (email: --email/--subject); only a typed secret goes to the request_flow_input tool.",
+  args: {
+    slug: { type: "positional", description: "Form slug (folder under flows/)", required: true },
+    full: { type: "boolean", description: "Include the full flow tree (secret values redacted)", required: false }
+  }
+});
+function statusFor(slug) {
+  const tree = readFlowTree(slug);
+  const config = [];
+  collectConfigStatus(tree, config);
+  return config;
+}
+function pendingInputHints(slug, config) {
+  const pending = config.filter((row) => row.needsInput);
+  if (pending.length === 0) return [];
+  const calls = pending.slice(0, MAX_PENDING_HINTS).map((row) => `${row.kind}: ${requestFlowInputCall(slug, row)}`);
+  const rest = pending.length - calls.length;
+  return [
+    ...repeatedKindHints(slug, pending),
+    `${pending.length} item${pending.length === 1 ? "" : "s"} still unwired. Wire each yourself with the command below when you know which resource is meant; the card is the fallback, and its result carries the destination \u2014 read the names from there rather than looking them up again.`,
+    ...calls,
+    ...rest > 0 ? [`\u2026and ${rest} more \u2014 see \`config\` above.`] : []
+  ];
+}
+function repeatedKindHints(slug, pending) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of pending) counts.set(row.kind, (counts.get(row.kind) ?? 0) + 1);
+  return [...counts].flatMap(([kind, count]) => {
+    if (count < 2) return [];
+    if (kind === "hubspotForm") {
+      return [
+        `${count} hubspotForm side effects are unwired. When they all send to the same HubSpot form: baker flows connect ${slug} --all --hubspot-form <formId>.`
+      ];
+    }
+    if (!FLOW_AGENT_DESTINATION_KINDS.includes(kind)) return [];
+    return [
+      `${count} ${kind} items are unwired. When they share one destination: baker flows connect ${slug} --all --type ${kind} [--resource <id>].`
+    ];
+  });
+}
+var MAX_PENDING_HINTS = 6;
+function inertSideEffectHints(tree) {
+  const dead = collectSideEffects(tree).flatMap(({ node, sideEffect }) => {
+    const triggers = flowNodeTriggers(node.nodeData);
+    if (!triggers.known) return [];
+    const triggerId = String(sideEffect.triggerId ?? "");
+    if (triggers.available.includes(triggerId)) return [];
+    const where = `${String(sideEffect.id ?? sideEffect.type)} on "${String(node.name ?? node.id)}"`;
+    const raises = triggers.available.length > 0 ? `It raises: ${triggers.available.join(", ")}.` : triggers.why ?? "That step raises nothing.";
+    return [`${where} fires on \`${triggerId || "(none)"}\`, which that step never raises. ${raises}`];
+  });
+  if (dead.length === 0) return [];
+  return [
+    `${dead.length} side effect${dead.length === 1 ? " has" : "s have"} a triggerId their step never raises, so ${dead.length === 1 ? "it never runs" : "they never run"} \u2014 no error, nothing half-written, just nothing. A triggerId belongs to the STEP, not to the side-effect type.`,
+    ...dead.slice(0, MAX_PENDING_HINTS),
+    ...dead.length > MAX_PENDING_HINTS ? [`\u2026and ${dead.length - MAX_PENDING_HINTS} more.`] : [],
+    "Fix each by setting the id its own step raises: `baker flows schema node <nodeType>` lists them."
+  ];
+}
+function funnelPlacementHint(slug) {
+  return `Whether this Form moves anyone along the company funnel is not in _data.json either: \`baker funnel\` names every Form no step counts. If it names this one, place its ending on the step it moves people to \u2014 \`submit:${slug}\`, or its booking trigger, both listed by \`baker funnel --moments\` \u2014 with \`baker funnel --step\`, which replaces the step it names, so keep that step's other ways in.`;
+}
+async function readDrift(slug) {
+  try {
+    const response = await apiPost("/api/flows/drift", { slug });
+    return response.data;
+  } catch {
+    return null;
+  }
+}
+function driftHints(slug, drift) {
+  if (drift === null) {
+    return [
+      "Could not check whether this Form's destination has changed under it. Treat that as UNKNOWN, not as healthy \u2014 a deleted HubSpot field refuses every submission while the visitor still sees the thank-you screen."
+    ];
+  }
+  const forms = drift.forms.filter((form) => form.slug === slug);
+  if (forms.length === 0) {
+    return drift.checkedAt === null ? [
+      "This Form's destination has never been checked, so nothing here says it is healthy \u2014 only that nothing was compared."
+    ] : [];
+  }
+  return forms.flatMap((form) => {
+    const repair = driftRepairHint(slug, form.formGuid, form.deadFields, form.sideEffectId);
+    return [`DESTINATION DRIFT (${form.severity}): ${form.summary}`, ...repair === null ? [] : [repair]];
+  });
+}
+function displayName(slug) {
+  const tree = readFlowTree(slug);
+  const name = tree.displayName;
+  return typeof name === "string" && name.trim() ? name.trim() : slug;
+}
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List Forms in this workspace with the count of confidential fields still needing setup. Example: baker flows list"
+  },
+  run: () => {
+    const flows = listFlowSlugs().map((slug) => ({
+      slug,
+      name: displayName(slug),
+      needsConfig: statusFor(slug).filter((c) => c.needsInput).length
+    }));
+    const pending = flows.filter((flow) => flow.needsConfig > 0);
+    writeJson({
+      ok: true,
+      data: { flows },
+      hints: [
+        ...pending.length > 0 ? [
+          `Still unwired: ${pending.map((flow) => `${flow.slug} (${flow.needsConfig})`).join(", ")}. \`baker flows show <slug>\` returns the command that wires each \u2014 most you run yourself.`
+        ] : [],
+        // "Set the conversions on the Forms" lands here first, and nothing in
+        // this family can do it — the conversion side effects it does offer
+        // fire a pixel and are not what any Baker report counts.
+        "Setting what a Form COUNTS is not in this family: a conversion is a named event held in Baker. `baker analytics conversions` lists what this company counts; `--flow <slug>` spells one Form's endings as keys you can count, traffic or no traffic."
+      ]
+    });
+  }
+});
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show a Form's confidential fields and their configuration status (never secret values). Example: baker flows show contact"
+  },
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    full: { type: "boolean", description: "Include the full flow tree (secret values redacted)" }
+  },
+  run: async ({ args }) => {
+    const slug = String(args.slug);
+    const tree = readFlowTree(slug);
+    const [drift, settings] = await Promise.all([readDrift(slug), readSettings(tree)]);
+    const config = withSettings(statusFor(slug), settings ?? {});
+    const response = {
+      slug,
+      name: displayName(slug),
+      config,
+      drift: drift === null ? null : drift.forms.filter((form) => form.slug === slug),
+      ...drift === null ? {} : { driftCheckedAt: drift.checkedAt },
+      ...args.full === true ? { tree: redactTree(tree) } : {}
+    };
+    writeJson({
+      ok: true,
+      data: response,
+      // Drift first, above everything. The other hints are about work still to
+      // do; this one is about leads already being lost, and it is the only
+      // thing here that is true of a Form that looks completely finished.
+      hints: [
+        ...driftHints(slug, drift),
+        ...inertSideEffectHints(tree),
+        ...pendingInputHints(slug, config),
+        // The question this command is asked — "is this Form wired up?" — has
+        // an answer that is not in this file at all. What a Form counts is a
+        // named event in Baker, and a Form can be perfectly configured, fire
+        // every pixel it has, and still report converting nobody.
+        `What this Form counts as a conversion is NOT in _data.json and not in any side effect here: it is a named event held in Baker. Read it, and this Form's own endings spelled as event keys, with \`baker analytics conversions --flow ${slug}\`.`,
+        funnelPlacementHint(slug)
+      ]
+    });
+  }
+});
+var flowsCommand = defineCommand({
+  meta: {
+    name: "flows",
+    description: `Read and shape this workspace's Forms (flows).
+
+Reads never reveal a secret value. Writes touch only the form's own _data.json \u2014 they stage structure, never a live system.
+
+Wire every destination yourself \u2014 no card for the user: an email (\`connect --email "a@x.com, b@x.com" --subject "New lead \u2014 Contact"\`; write the subject yourself), a webhook without a token (\`--url\`), and any connected platform once you know which resource is meant (\`baker flows options <kind>\` lists it; Calendly, SavvyCal, GoHighLevel steps; Google Sheets, Pipedrive, GoHighLevel, ActiveCampaign and HubSpot destinations; \`--same-as\` copies another Form's). A HubSpot step takes \`baker hubspot forms view <id> --as-node\`. \`show\` reads back where each destination sends; a credential is never shown.
+
+The request_flow_input tool (baker_ui MCP server) is only for what the user alone holds: a typed secret (a webhook token, Zapier, Crmble), a platform nobody connected, or several resources that could equally be meant.
+
+Examples:
+  baker flows list                                  # every Form + how many fields still need setup
+  baker flows show contact                          # one Form's confidential fields and their status
+  baker flows schema node customForm                # the shape of a step, before you author one
+  baker flows add-node contact --type text --name "Thanks"
+  baker flows add-side-effect contact --node <id> --type googleSpreadsheet
+  baker flows options calendly                      # what the connected account holds
+  baker flows connect contact --node book --resource <id>
+  baker flows connect contact --side-effect se-email-1 --email "ana@x.com, luis@x.com" --subject "New lead \u2014 Contact"
+  baker flows connect contact --side-effect se-hubspotForm-1 --hubspot-form <formId>   # --all: every unwired one
+  baker flows map contact --map A=name --map B=email --write
+Full guide: __tooling__/docs/tools/baker/flows.md`
+  },
+  subCommands: {
+    list: listCommand,
+    show: showCommand,
+    schema: () => import("./schema-CH654RZB.js").then((m) => m.schemaCommand),
+    "add-node": () => import("./add-3IZ3Z2PX.js").then((m) => m.addNodeCommand),
+    "add-side-effect": () => import("./add-3IZ3Z2PX.js").then((m) => m.addSideEffectCommand),
+    options: () => import("./options-TL5TPGHK.js").then((m) => m.optionsCommand),
+    connect: () => import("./connect-FFFNSJ2O.js").then((m) => m.connectCommand),
+    map: () => import("./map-Z3MEM6QX.js").then((m) => m.mapCommand),
+    normalize: () => import("./normalize-IUPOHEZJ.js").then((m) => m.normalizeCommand)
+  },
+  // Bare `baker flows` lists the Forms. This must be `default`, not `run`: citty falls
+  // through to `run` after dispatching a subcommand, so a `run` here would also print
+  // the list on every `baker flows show <slug>`.
+  default: "list"
+});
+export {
+  driftHints,
+  flowsCommand,
+  funnelPlacementHint,
+  inertSideEffectHints
+};
+//# sourceMappingURL=flows-DMMCSBWY.js.map

package/dist/fonts-G4JLXWX2.js

@@ -0,0 +1,36 @@
+import {
+  fetchJson,
+  fontsAdoptCommand,
+  fontsCheckCommand,
+  fontsCommand,
+  fontsFetchCommand,
+  lookupGoogleCss
+} from "./chunk-FL2KIDPV.js";
+import "./chunk-7POQSUPH.js";
+import "./chunk-YQICNXIA.js";
+import "./chunk-ABEIEHOV.js";
+import "./chunk-UFKO626N.js";
+import "./chunk-XRIM7NYV.js";
+import "./chunk-YYPWVQZQ.js";
+import "./chunk-F3CZFUXZ.js";
+import "./chunk-U7YR5CZL.js";
+import "./chunk-VI5YQQ63.js";
+import "./chunk-JX7BX2NB.js";
+import "./chunk-JGM4WGC2.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-NAA4CKZZ.js";
+import "./chunk-D5NEIESR.js";
+import "./chunk-57KKVDDR.js";
+import "./chunk-QANGHND7.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  fetchJson,
+  fontsAdoptCommand,
+  fontsCheckCommand,
+  fontsCommand,
+  fontsFetchCommand,
+  lookupGoogleCss
+};
+//# sourceMappingURL=fonts-G4JLXWX2.js.map

package/dist/forecast-OOP4K5DE.js

@@ -0,0 +1,118 @@
+import {
+  LINKEDIN_FORECAST_DEFAULT_DAYS,
+  linkedinForecastRequestSchema
+} from "./chunk-DD3C6TSW.js";
+import {
+  exitOnInvalidArgs,
+  handleLinkedinError,
+  loadTargetingArg,
+  resolveAccountIdArg
+} from "./chunk-PGD7USOH.js";
+import {
+  writeAdsJson
+} from "./chunk-2VIZ4UUZ.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-U6RONIJC.js";
+import "./chunk-JGM4WGC2.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-NAA4CKZZ.js";
+import {
+  apiPost
+} from "./chunk-6YLNY6CK.js";
+import "./chunk-D5NEIESR.js";
+import "./chunk-57KKVDDR.js";
+import "./chunk-QANGHND7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/forecast.ts
+import { defineCommand } from "citty";
+var FLAG_OF_FIELD = {
+  objectiveType: "--objective",
+  costType: "--cost-type",
+  campaignType: "--campaign-type",
+  startDate: "--start",
+  days: "--days",
+  dailyBudget: "--daily-budget",
+  totalBudget: "--total-budget",
+  bid: "--bid",
+  optimizationTarget: "--optimization-target",
+  targetingCriteria: "--targeting"
+};
+function parseMoney(raw) {
+  if (typeof raw !== "string" || raw.trim() === "") return void 0;
+  const m = /^(\d+(?:\.\d+)?)(?:\s+([A-Za-z]{3}))?$/.exec(raw.trim());
+  if (!m?.[1]) return raw;
+  return m[2] ? { amount: m[1], currencyCode: m[2].toUpperCase() } : { amount: m[1] };
+}
+var forecastCommand = defineCommand({
+  meta: {
+    name: "forecast",
+    description: `Forecast what a campaign that doesn't exist yet would deliver \u2014 LinkedIn's own estimate, the "Forecasted results" Campaign Manager shows while building one.
+
+Returns, for the whole period: results (impressions, clicks, leads, spend, \u2026), LinkedIn's unit costs (cpc, cpm, costPerLead, \u2026) and rates (ctr, \u2026), each as { value, low, high }. Unit costs are LinkedIn's per-result estimates and need not equal spend \xF7 results; spend can stay under the budget when the bid or audience caps delivery.
+
+A budget is required (--daily-budget or --total-budget). With --bid it forecasts that manual bid (get one from \`bid-pricing\`); without it, LinkedIn's automated bidding for the objective (LEAD_GENERATION, WEBSITE_VISIT, BRAND_AWARENESS, VIDEO_VIEW \u2014 others need --bid or --optimization-target). The period starts tomorrow (or --start) and lasts --days (default ${LINKEDIN_FORECAST_DEFAULT_DAYS}). Amounts without a currency use the ad account's.
+
+Start here:
+  baker ads linkedin forecast --account-id 503001492 --objective LEAD_GENERATION --total-budget 7250 --days 28 --targeting-file targeting.json
+  baker ads linkedin forecast --account-id 503001492 --objective LEAD_GENERATION --bid 5.57 --cost-type CPC --daily-budget "250 EUR" --targeting-file targeting.json`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    objective: { type: "string", description: "Objective type (e.g. LEAD_GENERATION, WEBSITE_VISIT)" },
+    "cost-type": { type: "string", description: "Bid type of --bid: CPC (default) | CPM | CPV", default: "CPC" },
+    "campaign-type": {
+      type: "string",
+      description: "SPONSORED_UPDATES (default, sponsored content) | SPONSORED_INMAILS | DYNAMIC",
+      default: "SPONSORED_UPDATES"
+    },
+    "daily-budget": { type: "string", description: "e.g. '250' or '250 EUR'" },
+    "total-budget": { type: "string", description: "Budget for the whole period, e.g. '7250' or '7250 EUR'" },
+    bid: { type: "string", description: "Manual bid, e.g. '5.57' or '5.57 EUR'. Omit for automated bidding" },
+    "optimization-target": {
+      type: "string",
+      description: "Automated-bidding goal when --bid is omitted (e.g. MAX_LEAD, MAX_CLICK)"
+    },
+    start: { type: "string", description: "First day, YYYY-MM-DD (default tomorrow, UTC)" },
+    days: { type: "string", description: `Length of the period in days (default ${LINKEDIN_FORECAST_DEFAULT_DAYS})` },
+    targeting: { type: "string", description: "Inline JSON targetingCriteria" },
+    "targeting-file": { type: "string", description: "Path to JSON file with targetingCriteria" },
+    full: { type: "boolean", description: "Also return LinkedIn's daily / 7-day / 30-day series", default: false },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    const targetingCriteria = loadTargetingArg(args);
+    const parsed = linkedinForecastRequestSchema.safeParse({
+      accountId,
+      objectiveType: args.objective ? String(args.objective).toUpperCase() : void 0,
+      costType: String(args["cost-type"]).toUpperCase(),
+      campaignType: String(args["campaign-type"]).toUpperCase(),
+      startDate: args.start || void 0,
+      days: args.days ? Number(args.days) : void 0,
+      dailyBudget: parseMoney(args["daily-budget"]),
+      totalBudget: parseMoney(args["total-budget"]),
+      bid: parseMoney(args.bid),
+      optimizationTarget: args["optimization-target"] ? String(args["optimization-target"]).toUpperCase() : void 0,
+      targetingCriteria,
+      full: Boolean(args.full),
+      skipCache: Boolean(args["no-cache"])
+    });
+    if (!parsed.success) exitOnInvalidArgs(parsed.error.issues, FLAG_OF_FIELD);
+    try {
+      const data = await apiPost("/api/ads/linkedin/forecast", parsed.data);
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+export {
+  forecastCommand
+};
+//# sourceMappingURL=forecast-OOP4K5DE.js.map

package/dist/forecast-V65WS5QG.js

@@ -0,0 +1,168 @@
+import {
+  exitWithServiceReadError
+} from "./chunk-VDTOAZ6W.js";
+import {
+  failWriteValidation,
+  keywordEntries,
+  microsFlag,
+  requireCustomerId
+} from "./chunk-5PMEMWKS.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-WHWSLDNR.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-6UNOK7WV.js";
+import {
+  googleKeywordForecastRequestSchema
+} from "./chunk-V57TZQPI.js";
+import {
+  getManagerIdForCustomer,
+  writeJsonEnvelope
+} from "./chunk-2VIZ4UUZ.js";
+import "./chunk-UFKO626N.js";
+import "./chunk-XRIM7NYV.js";
+import "./chunk-A6WKCV3V.js";
+import "./chunk-U7YR5CZL.js";
+import "./chunk-VI5YQQ63.js";
+import "./chunk-JX7BX2NB.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-NAA4CKZZ.js";
+import {
+  apiPost
+} from "./chunk-6YLNY6CK.js";
+import "./chunk-D5NEIESR.js";
+import "./chunk-57KKVDDR.js";
+import {
+  registerSchema
+} from "./chunk-QANGHND7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/keywords/forecast.ts
+import { defineCommand } from "citty";
+var ARGS = {
+  "customer-id": { type: "string", description: "Google Ads customer ID (10 digits, no dashes)" },
+  text: {
+    type: "string",
+    description: 'Keywords to forecast, comma-separated, optional ":MATCH_TYPE" suffix each (e.g. "solar panels:PHRASE,placas solares")'
+  },
+  file: { type: "string", description: "Text file with one keyword[:MATCH_TYPE] per line" },
+  "match-type": { type: "string", description: "Default match type: EXACT | PHRASE | BROAD" },
+  "max-cpc": {
+    type: "string",
+    description: "Max CPC bid in major currency units \u2014 Manual CPC (or the ceiling under Maximize clicks)"
+  },
+  "daily-spend": {
+    type: "string",
+    description: "Daily spend in major currency units \u2014 Maximize clicks / Maximize conversions (or the daily budget under Manual CPC)"
+  },
+  strategy: {
+    type: "string",
+    description: "MANUAL_CPC | MAXIMIZE_CLICKS | MAXIMIZE_CONVERSIONS (default: MANUAL_CPC with --max-cpc alone, else MAXIMIZE_CLICKS)"
+  },
+  location: { type: "string", description: "Geo target id(s), comma-separated (see `keywords locations`)" },
+  language: { type: "string", description: "Language id (see `keywords languages`)" },
+  start: {
+    type: "string",
+    description: "First day forecast, YYYY-MM-DD (future). With --end; default: the 30 days from tomorrow"
+  },
+  end: { type: "string", description: "Last day forecast, YYYY-MM-DD (within a year)" },
+  currency: { type: "string", description: "Currency for the money figures (default: the account's)" }
+};
+registerSchema({
+  command: "ads.google.keywords.forecast",
+  description: 'Forecast clicks, cost, conversions and average CPC / CPA for a set of keywords under one bidding strategy, over a period (Keyword Planner, v25). Start here: `baker ads google keywords forecast --customer-id 1234567890 --text "solar panels:PHRASE,placas solares:EXACT" --max-cpc 1.5 --location 2724 --language 1003`. Returns { source: "keyword_planner_forecast", period, forecast_* } \u2014 Google\'s prediction for the whole period, never an account result.',
+  args: Object.fromEntries(
+    Object.entries(ARGS).map(([name, arg]) => [
+      name,
+      { type: arg.type, description: arg.description, required: false }
+    ])
+  )
+});
+function amount(args, flag) {
+  return args[flag] === void 0 ? void 0 : microsFlag(args[flag], `--${flag}`);
+}
+function namedStrategy(args, maxCpc, spend) {
+  if (typeof args.strategy === "string") return args.strategy.toUpperCase();
+  return maxCpc !== void 0 && spend === void 0 ? "MANUAL_CPC" : "MAXIMIZE_CLICKS";
+}
+function forecastBidding(args) {
+  const maxCpc = amount(args, "max-cpc");
+  const spend = amount(args, "daily-spend");
+  const strategy = namedStrategy(args, maxCpc, spend);
+  if (strategy === "MANUAL_CPC") {
+    if (maxCpc === void 0) return { ok: false, message: "Manual CPC needs --max-cpc" };
+    return { ok: true, bidding: { strategy, maxCpcBidMicros: maxCpc, ...spend ? { dailyBudgetMicros: spend } : {} } };
+  }
+  if (strategy !== "MAXIMIZE_CLICKS" && strategy !== "MAXIMIZE_CONVERSIONS") {
+    return {
+      ok: false,
+      message: `--strategy ${strategy} is not one Google forecasts: MANUAL_CPC | MAXIMIZE_CLICKS | MAXIMIZE_CONVERSIONS`
+    };
+  }
+  if (spend === void 0) return { ok: false, message: `${strategy} needs --daily-spend` };
+  if (strategy === "MAXIMIZE_CONVERSIONS") return { ok: true, bidding: { strategy, dailyTargetSpendMicros: spend } };
+  return {
+    ok: true,
+    bidding: { strategy, dailyTargetSpendMicros: spend, ...maxCpc ? { maxCpcBidCeilingMicros: maxCpc } : {} }
+  };
+}
+function hints(data) {
+  const out = [
+    `Google's prediction for ${data.period.startDate}\u2013${data.period.endDate}, not an account result: quote it as a forecast.`
+  ];
+  if (data.forecast_clicks === null && data.forecast_cost_micros === null) {
+    out.push(
+      "Google forecast nothing for these keywords \u2014 too little search volume in the chosen locations, or the bid is too low to win auctions."
+    );
+  }
+  return out;
+}
+var forecastCommand = defineCommand({
+  meta: {
+    name: "forecast",
+    description: `Forecast clicks, cost and conversions for keywords under one bidding strategy (Keyword Planner).
+
+Examples:
+  baker ads google keywords forecast --customer-id 1234567890 --text "solar panels:PHRASE,placas solares:EXACT" --max-cpc 1.5 --location 2724 --language 1003
+  baker ads google keywords forecast --customer-id 1234567890 --text "crm software" --match-type BROAD --daily-spend 20 --strategy MAXIMIZE_CONVERSIONS --start 2026-11-01 --end 2026-11-30`
+  },
+  args: ARGS,
+  run: async ({ args, rawArgs }) => {
+    const customerId = requireCustomerId(args);
+    const keywords = keywordEntries(args, rawArgs);
+    const bidding = forecastBidding(args);
+    if (!bidding.ok) failWriteValidation(bidding.message);
+    const managerId = getManagerIdForCustomer(customerId);
+    const request = googleKeywordForecastRequestSchema.safeParse({
+      customerId,
+      ...managerId ? { managerId } : {},
+      adGroups: [{ keywords }],
+      ...args.location ? {
+        locationIds: String(args.location).split(",").map((id) => id.trim())
+      } : {},
+      ...args.language ? { languageId: String(args.language) } : {},
+      bidding: bidding.bidding,
+      ...args.start ? { startDate: args.start } : {},
+      ...args.end ? { endDate: args.end } : {},
+      ...args.currency ? { currencyCode: String(args.currency).toUpperCase() } : {}
+    });
+    if (!request.success) {
+      const issue = request.error.issues[0];
+      failWriteValidation(issue ? `${issue.path.join(".")}: ${issue.message}` : "Invalid forecast");
+    }
+    try {
+      const { data } = await apiPost(
+        "/api/ads/google/keywords/forecast",
+        request.data
+      );
+      writeJsonEnvelope({ ok: true, data, hints: hints(data) });
+    } catch (err) {
+      exitWithServiceReadError(err);
+    }
+  }
+});
+export {
+  forecastBidding,
+  forecastCommand
+};
+//# sourceMappingURL=forecast-V65WS5QG.js.map