@koda-sl/baker-cli 0.574.0 → 0.575.0-dev.85f21462e

package/dist/flows-VJTWU3SU.js

@@ -0,0 +1,340 @@
+import {
+  currentMapping
+} from "./chunk-6J2UZJ6F.js";
+import {
+  collectConfigStatus,
+  collectSideEffects,
+  flowsDir,
+  listFlowSlugs,
+  readFlowTree,
+  readSettings,
+  redactTree,
+  requestFlowInputCall,
+  walkNodes,
+  withSettings
+} from "./chunk-BJH2G3QF.js";
+import {
+  landingGraphFiles
+} from "./chunk-Z3ENMCFE.js";
+import {
+  FLOW_AGENT_DESTINATION_KINDS,
+  driftRepairHint,
+  flowNodeTriggers
+} from "./chunk-BTOGDXA4.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-3WOFZTGC.js";
+import "./chunk-IMS53EQU.js";
+import {
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+import "./chunk-OFSUVUXT.js";
+import "./chunk-OMLZ35HJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/index.ts
+import { readdir } from "fs/promises";
+import { join, resolve } from "path";
+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 side effect says when it fires (triggerId), what it records (eventName, conversionLabel, conversionId, tagIds), where it sends (email recipients and subject; the spreadsheet, tab and header row; the HubSpot form by name) and what it sends (`mapping`: one `destination \u2190 source` line per mapped value) \u2014 never a credential. `steps` lists every step with the moments it raises; `usedBy` names the landings that render the Form. A sheet's whole header row (`destination.columns`, every column letter and header, mapped or not) comes only with --full. 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: "Also include the full flow tree (secret values redacted) and each sheet destination's whole header row (`destination.columns`)",
+      required: false
+    }
+  }
+});
+function statusFor(slug) {
+  const tree = readFlowTree(slug);
+  const config = [];
+  collectConfigStatus(tree, config);
+  return config;
+}
+function showConfig(tree, settings, { full = false } = {}) {
+  const config = [];
+  collectConfigStatus(tree, config);
+  const mappings = new Map(
+    collectSideEffects(tree).map(({ sideEffect }) => [String(sideEffect.id ?? ""), currentMapping(sideEffect)])
+  );
+  return withSettings(config, settings).map((row) => {
+    const { columns, ...destination } = row.destination ?? {};
+    const headers = new Map(
+      (Array.isArray(columns) ? columns : []).map((column) => [
+        String(column.letter),
+        String(column.header)
+      ])
+    );
+    const mapping = (row.sideEffectId ? mappings.get(row.sideEffectId) ?? [] : []).map(
+      (line) => line.replace(
+        /^([A-Z]{1,3}) ← /,
+        (whole, letter) => headers.has(letter) ? `${letter} "${headers.get(letter)}" \u2190 ` : whole
+      )
+    );
+    return {
+      ...row,
+      ...row.destination ? { destination: full ? row.destination : destination } : {},
+      ...mapping.length > 0 ? { mapping } : {}
+    };
+  });
+}
+function flowSteps(tree) {
+  return walkNodes(tree).flatMap((node) => {
+    const nodeData = node.nodeData;
+    if (typeof nodeData?.type !== "string") return [];
+    return [
+      {
+        id: String(node.id ?? ""),
+        name: String(node.name ?? ""),
+        type: nodeData.type,
+        raises: [...flowNodeTriggers(nodeData).available]
+      }
+    ];
+  });
+}
+var LANDINGS_MAX = 300;
+async function landingsRendering(root, slug) {
+  const pages = await readdir(join(root, "src/pages"), { withFileTypes: true }).catch(() => []);
+  const formDir = `src/lib/flow-engine/flows/${slug}/`;
+  const users = /* @__PURE__ */ new Set();
+  for (const page of pages.filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).slice(0, LANDINGS_MAX)) {
+    const files = await landingGraphFiles(root, page.name);
+    if ([...files].some((file) => file.startsWith(formDir))) users.add(page.name.replace(/--\d+$/, ""));
+  }
+  return [...users].sort();
+}
+function workspaceRoot() {
+  return resolve(flowsDir(), "../../../..");
+}
+function unreadableDestinationHints(config, settings) {
+  const unreadable = config.filter((row) => row.sideEffectId && settings[row.sideEffectId] === null);
+  if (unreadable.length === 0) return [];
+  return [
+    `Baker cannot read where ${unreadable.map((row) => row.sideEffectId).join(", ")} send${unreadable.length === 1 ? "s" : ""}: ${unreadable.length === 1 ? "it was" : "they were"} sealed before Baker recorded which company a destination belongs to, or copied from another company's Form. Do not guess the destination. If the user names it, re-wire it with \`baker flows connect\` and it reads back from then on.`
+  ];
+}
+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 steps and every side effect: when it fires, where it sends (sheet and tab, HubSpot form, email recipients), what each mapped value is, and what is still unwired (never secret values). Example: baker flows show contact"
+  },
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    full: {
+      type: "boolean",
+      description: "Also include the full flow tree (secret values redacted) and each sheet destination's whole header row (`destination.columns`)"
+    }
+  },
+  run: async ({ args }) => {
+    const slug = String(args.slug);
+    const tree = readFlowTree(slug);
+    const [drift, settings, usedBy] = await Promise.all([
+      readDrift(slug),
+      readSettings(tree, { named: true }),
+      landingsRendering(workspaceRoot(), slug)
+    ]);
+    const config = showConfig(tree, settings ?? {}, { full: args.full === true });
+    const response = {
+      slug,
+      name: displayName(slug),
+      config,
+      steps: flowSteps(tree),
+      usedBy,
+      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),
+        ...unreadableDestinationHints(config, settings ?? {}),
+        // 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 steps, side effects, destinations and mappings
+  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-RDVJQ5VW.js").then((m) => m.schemaCommand),
+    "add-node": () => import("./add-DWKVVW76.js").then((m) => m.addNodeCommand),
+    "add-side-effect": () => import("./add-DWKVVW76.js").then((m) => m.addSideEffectCommand),
+    options: () => import("./options-HT27WLNS.js").then((m) => m.optionsCommand),
+    connect: () => import("./connect-NUZQSIGL.js").then((m) => m.connectCommand),
+    map: () => import("./map-DQ65PS65.js").then((m) => m.mapCommand),
+    normalize: () => import("./normalize-XRVNJTML.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,
+  flowSteps,
+  flowsCommand,
+  funnelPlacementHint,
+  inertSideEffectHints,
+  landingsRendering,
+  showConfig,
+  unreadableDestinationHints
+};
+//# sourceMappingURL=flows-VJTWU3SU.js.map

package/dist/fonts-SEMIVGXJ.js

@@ -0,0 +1,39 @@
+import {
+  fetchJson,
+  fontsAdoptCommand,
+  fontsCheckCommand,
+  fontsCommand,
+  fontsFetchCommand,
+  lookupGoogleCss
+} from "./chunk-423G75A7.js";
+import "./chunk-UQTINFCP.js";
+import "./chunk-VSHXHSIW.js";
+import "./chunk-U6EQMX3B.js";
+import "./chunk-T4HIFVNK.js";
+import "./chunk-CGLNCFAG.js";
+import "./chunk-YNWBIAXJ.js";
+import "./chunk-F3CZFUXZ.js";
+import "./chunk-EFZVDV7F.js";
+import "./chunk-U3LO5TDH.js";
+import "./chunk-TJTCHTR4.js";
+import "./chunk-BTOGDXA4.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-3WOFZTGC.js";
+import "./chunk-IMS53EQU.js";
+import "./chunk-OFSUVUXT.js";
+import "./chunk-OMLZ35HJ.js";
+import "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  fetchJson,
+  fontsAdoptCommand,
+  fontsCheckCommand,
+  fontsCommand,
+  fontsFetchCommand,
+  lookupGoogleCss
+};
+//# sourceMappingURL=fonts-SEMIVGXJ.js.map

package/dist/forecast-EHOMHLUH.js

@@ -0,0 +1,169 @@
+import {
+  exitWithServiceReadError
+} from "./chunk-MNFJQRUO.js";
+import {
+  failWriteValidation,
+  keywordEntries,
+  microsFlag,
+  requireCustomerId
+} from "./chunk-AFWLBOIN.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-YT6YI47O.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-HZ7QUFUW.js";
+import "./chunk-QALAJNBG.js";
+import {
+  googleKeywordForecastRequestSchema
+} from "./chunk-WZXMZFVB.js";
+import {
+  getManagerIdForCustomer,
+  writeJsonEnvelope
+} from "./chunk-VJUVTMHY.js";
+import "./chunk-T4HIFVNK.js";
+import "./chunk-CGLNCFAG.js";
+import "./chunk-E2G2USTA.js";
+import "./chunk-EFZVDV7F.js";
+import "./chunk-U3LO5TDH.js";
+import "./chunk-TJTCHTR4.js";
+import "./chunk-3WOFZTGC.js";
+import "./chunk-IMS53EQU.js";
+import {
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+import "./chunk-OFSUVUXT.js";
+import "./chunk-OMLZ35HJ.js";
+import {
+  registerSchema
+} from "./chunk-NXNOXZGB.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; dashes are fine)" },
+  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-EHOMHLUH.js.map

package/dist/forecast-VODA7N3G.js

@@ -0,0 +1,121 @@
+import {
+  LINKEDIN_FORECAST_DEFAULT_DAYS,
+  linkedinForecastRequestSchema
+} from "./chunk-K3VMHRLJ.js";
+import {
+  exitOnInvalidArgs,
+  handleLinkedinError,
+  loadTargetingArg,
+  resolveAccountIdArg
+} from "./chunk-LQRPFL2N.js";
+import {
+  writeAdsJson
+} from "./chunk-VJUVTMHY.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-HPF3USL2.js";
+import "./chunk-BTOGDXA4.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-3WOFZTGC.js";
+import "./chunk-IMS53EQU.js";
+import {
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+import "./chunk-OFSUVUXT.js";
+import "./chunk-OMLZ35HJ.js";
+import "./chunk-NXNOXZGB.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-VODA7N3G.js.map