@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.495.0-dev.c2b64ccca

package/dist/add-JAXBNDLC.js

@@ -0,0 +1,97 @@
+import {
+  reportError
+} from "./chunk-TE3N5AGN.js";
+import {
+  apiPost
+} from "./chunk-OSWCEDFE.js";
+import "./chunk-D53AAUG4.js";
+import "./chunk-FZKUUI3F.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4WYEGE4N.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/inspiration/add.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "landing.inspiration.add",
+  description: "Add someone else's landing page to the reference library and save it to this company. Returns immediately \u2014 studying a page takes a few minutes, so never wait on it. Use it when the client names a site they admire, or when you find a competitor page worth learning from. Never point it at a page we built: it is refused, because the source is already in the project and reading a screenshot of it tells you less than opening the file.",
+  args: {
+    url: { type: "string", description: "Landing page address", required: true },
+    note: { type: "string", description: "Why this page is worth keeping", required: false },
+    refresh: {
+      type: "boolean",
+      description: "Study the page again even if it is already in the library. Use when the user says the page has changed or the saved sections look outdated",
+      required: false
+    }
+  }
+});
+function addHints(data, { refresh }) {
+  if (data.refreshDeclined === "studying") {
+    return [
+      "This page is already being studied \u2014 no second study was started. Search for it later in the turn or in a later one."
+    ];
+  }
+  if (data.refreshDeclined === "too_soon") {
+    return [
+      "This page was just studied a few minutes ago, so it was not studied again \u2014 its sections are already current.",
+      `Search it with: baker landing inspiration search --domain ${new URL(data.canonicalUrl).hostname}`
+    ];
+  }
+  if (data.alreadyKnown) {
+    return [
+      "This page was already in the library, so nothing was re-studied \u2014 its sections are searchable now.",
+      `Search it with: baker landing inspiration search --domain ${new URL(data.canonicalUrl).hostname}`,
+      "If the user says the live page looks different from what the library shows, run this again with --refresh."
+    ];
+  }
+  return [
+    refresh ? "Studying it again from the live site \u2014 this takes a few minutes. Until it lands, search results still show the old version, so don't build from them yet." : "Studying this page takes a few minutes. Don't wait on it \u2014 carry on, and search for it later in the turn or in a later one.",
+    "Meanwhile, search what is already in the library: baker landing inspiration search '<what you want to see>' --scope all",
+    "This is saved and being studied now, so it is listed as already applied \u2014 tell the user it is kept whatever they do with this chat.",
+    // The save is not a promise that the study succeeded. An agent that
+    // assumes it did will later search its own favorites, find nothing,
+    // and have no idea why.
+    "The save sticks even if the page turns out to be unreadable \u2014 `baker landing inspiration favorites` reports those separately as unreadable, so check there rather than assuming this page is searchable."
+  ];
+}
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Add someone else's landing page to the reference library. Example: baker landing inspiration add https://linear.app --note 'the client likes this density'. Add --refresh to study a saved page again after the site changed"
+  },
+  args: {
+    url: { type: "positional", description: "Landing page address", required: true },
+    note: { type: "string", description: "Why this page is worth keeping", required: false },
+    refresh: {
+      type: "boolean",
+      description: "Study it again even if it is already in the library",
+      required: false,
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const data = await apiPost("/api/landing-inspiration/add", {
+        url: args.url,
+        note: args.note,
+        favorite: true,
+        refresh: args.refresh || void 0
+      });
+      const hints = addHints(data, { refresh: args.refresh });
+      writeJson({
+        ok: true,
+        data: { id: data.sourceId, url: data.canonicalUrl, status: data.status, already_known: data.alreadyKnown },
+        hints
+      });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+export {
+  addCommand,
+  addHints
+};
+//# sourceMappingURL=add-JAXBNDLC.js.map

package/dist/add-KAMQP5RM.js

@@ -0,0 +1,302 @@
+import {
+  flowDataPath,
+  isUsableStepNameKey,
+  readFlowTree,
+  requestFlowInputCall,
+  stepNameKey,
+  walkNodes,
+  writeFlowTree
+} from "./chunk-M525HJTA.js";
+import {
+  flowCatalogEntry,
+  flowCatalogTypes,
+  flowNodeTriggers
+} from "./chunk-MV2J73HP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-I2DNBEV6.js";
+import "./chunk-OSWCEDFE.js";
+import "./chunk-D53AAUG4.js";
+import "./chunk-FZKUUI3F.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4WYEGE4N.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/add.ts
+import { randomUUID } from "crypto";
+import { defineCommand } from "citty";
+function unknownType(kind, type) {
+  writeJson({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: `No ${kind} type "${type}".`,
+      fix: `Known types: ${flowCatalogTypes(kind).join(", ")}. See: baker flows schema ${kind}`
+    }
+  });
+  process.exit(1);
+}
+function concrete(skeleton, replacements) {
+  return { ...structuredClone(skeleton), ...replacements };
+}
+function stepNameRefusal(nodes, name) {
+  const key = stepNameKey(name);
+  if (!isUsableStepNameKey(key)) {
+    return {
+      message: `"${name}" cannot be a step name: it becomes the constant \`${key || "(empty)"}\`, which is not a valid identifier.`,
+      fix: 'A step name becomes `export const <NAME> = \u2026` in the form\'s generated code, so it must start with a letter and hold only letters, digits, spaces and dashes. Try "Your Details" rather than "1. Your details".'
+    };
+  }
+  const clash = nodes.find((node) => typeof node.name === "string" && stepNameKey(node.name) === key);
+  if (!clash) return null;
+  return {
+    message: `This form already has a step named "${clash.name}", which collides with "${name}".`,
+    fix: `Both become the constant \`${key}\`, and the form's generated code cannot hold it twice. Pick a name that differs by more than case, spacing or punctuation.`
+  };
+}
+registerSchema({
+  command: "flows.add-node",
+  description: "Add a step to a form with a valid skeleton \u2014 fresh UUID, explicit condition, correct nodeData discriminator, and form.external:null for a widget. Author its copy and conditions afterwards by editing _data.json.",
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    type: { type: "string", description: "Node type (see: baker flows schema node)", required: true },
+    name: { type: "string", description: "Step name \u2014 unique, Title Case", required: true },
+    parent: { type: "string", description: "Parent node id. Omit to append to the root's children.", required: false }
+  }
+});
+var addNodeCommand = defineCommand({
+  meta: {
+    name: "add-node",
+    description: 'Add a step to a form, with the skeleton its type requires. Example: baker flows add-node contact --type customForm --name "Contact Info"'
+  },
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    type: { type: "string", description: "Node type", required: true },
+    name: { type: "string", description: "Step name \u2014 unique, Title Case", required: true },
+    parent: { type: "string", description: "Parent node id (default: the root)" }
+  },
+  run: ({ args }) => {
+    const slug = String(args.slug);
+    const type = String(args.type);
+    const name = String(args.name).trim();
+    const entry = flowCatalogEntry("node", type) ?? unknownType("node", type);
+    const tree = readFlowTree(slug);
+    const nodes = walkNodes(tree);
+    const refusal = stepNameRefusal(nodes, name);
+    if (refusal) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: refusal.message.replace("This form", `"${slug}"`),
+          fix: refusal.fix
+        }
+      });
+      process.exit(1);
+    }
+    const parent = args.parent ? nodes.find((node2) => node2.id === String(args.parent)) : tree;
+    if (!parent) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `No node with id "${args.parent}" in "${slug}".`,
+          fix: `Nodes in this form: ${nodes.map((node2) => `${node2.id} (${node2.name})`).join(", ")}`
+        }
+      });
+      process.exit(1);
+    }
+    const node = concrete(entry.skeleton, { id: randomUUID(), name });
+    if (!Array.isArray(parent.children)) parent.children = [];
+    parent.children.push(node);
+    writeFlowTree(slug, tree);
+    writeJson({
+      ok: true,
+      data: { slug, nodeId: node.id, type, parentId: parent.id ?? null, path: flowDataPath(slug) },
+      hints: [
+        `Now fill in this step's \`ai\` field and its copy by editing ${flowDataPath(slug)}.`,
+        // Said on every step added, because the moment a Form's shape changes
+        // is the moment its outcome can move — and a Form nobody named an
+        // outcome for reports zero conversions rather than an error.
+        `Say what this Form counts before you finish: \`baker analytics conversions --flow ${slug}\` lists every ending already spelled as an event key, including this step's. Nothing in _data.json decides it.`,
+        ...entry.owners?.["nodeData.form.external"] === "request_flow_input" ? [
+          `Pick this ${type} step's resource: ${requestFlowInputCall(slug, pendingItem("node", String(node.id), type))}.`
+        ] : [],
+        ...entry.gotcha ? [entry.gotcha] : []
+      ]
+    });
+  }
+});
+function resolveTrigger(node, requested) {
+  const triggers = flowNodeTriggers(node.nodeData);
+  const where = `Step "${String(node.name ?? node.id)}"${triggers.type ? ` (a ${triggers.type} step)` : ""}`;
+  const raises = triggers.available.length > 0 ? `It raises: ${triggers.available.join(", ")}.` : triggers.why ?? "";
+  const no = (message, fix) => ({ ok: false, message, fix });
+  if (!triggers.known) {
+    return requested ? { ok: true, triggerId: requested } : no(`${where} is not a node type this command knows, so --trigger is required.`, triggers.why ?? "");
+  }
+  if (requested) {
+    return triggers.available.includes(requested) ? { ok: true, triggerId: requested } : no(
+      `${where} never raises \`${requested}\`, so a side effect carrying it would be written, pass every check, and never run.`,
+      raises
+    );
+  }
+  return triggers.completion ? { ok: true, triggerId: triggers.completion } : no(`${where} has no trigger a side effect can answer.`, raises);
+}
+function freeSideEffectId(type, taken) {
+  for (let n = 1; ; n++) {
+    const candidate = `se-${type}-${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+function sameTrackingSideEffect(node, type, triggerId) {
+  if (flowCatalogEntry("side-effect", type)?.owners?.tagIds !== "tags") return null;
+  const effects = Array.isArray(node.sideEffects) ? node.sideEffects : [];
+  for (const raw of effects) {
+    const effect = raw;
+    if (effect?.type === type && effect.triggerId === triggerId) return effect;
+  }
+  return null;
+}
+function secondPixelHint(node, type, triggerId) {
+  const already = sameTrackingSideEffect(node, type, triggerId);
+  if (!already) return null;
+  const event = typeof already.eventName === "string" ? ` with event "${already.eventName}"` : "";
+  return `"${String(node.name ?? node.id)}" already reports \`${triggerId}\` to ${type} as "${String(already.id)}"${event}. Give this one a different event; to change that conversion, edit "${String(already.id)}" and delete this one \u2014 the same event to the same tag counts every conversion twice.`;
+}
+function pendingItem(target, nodeId, kind, sideEffectId) {
+  return {
+    target,
+    nodeId,
+    kind,
+    status: `${kind} \u2014 not configured`,
+    needsInput: true,
+    ...sideEffectId ? { sideEffectId } : {}
+  };
+}
+function configureHints(slug, nodeId, id, type, needsCard) {
+  if (!needsCard) return [];
+  return [
+    `Configure it: ${requestFlowInputCall(slug, pendingItem("sideEffect", nodeId, type, id))}. Read the destination off that call's result.`
+  ];
+}
+registerSchema({
+  command: "flows.add-side-effect",
+  description: "Add a side effect to a step with a valid skeleton \u2014 encryptedConfig:null for a CRM, a tagIds slot for a pixel, and no oauthProviderId key. Then set where it sends with `baker flows connect` (an email: --email/--subject, written by you); only a typed secret goes to request_flow_input.",
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    node: { type: "string", description: "Id of the step that fires it", required: true },
+    type: { type: "string", description: "Side-effect type (see: baker flows schema side-effect)", required: true },
+    id: { type: "string", description: "Side-effect id. Defaults to se-{type}-{n}.", required: false },
+    trigger: {
+      type: "string",
+      description: "triggerId. Defaults to the moment the step named by --node completes, which is a different id per node type. Pass this only for a non-completion moment (a HubSpot form's onFormReady, a Calendly page view, one of several iframe events); an id the step never raises is refused.",
+      required: false
+    }
+  }
+});
+var addSideEffectCommand = defineCommand({
+  meta: {
+    name: "add-side-effect",
+    description: "Add a side effect to a step, with the skeleton its type requires. Example: baker flows add-side-effect contact --node <id> --type googleSpreadsheet"
+  },
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    node: { type: "string", description: "Id of the step that fires it", required: true },
+    type: { type: "string", description: "Side-effect type", required: true },
+    id: { type: "string", description: "Side-effect id (default se-{type}-{n})" },
+    trigger: {
+      type: "string",
+      description: "triggerId, for a non-completion moment. Default: whatever the step named by --node raises"
+    }
+  },
+  run: ({ args }) => {
+    const slug = String(args.slug);
+    const type = String(args.type);
+    const entry = flowCatalogEntry("side-effect", type) ?? unknownType("side-effect", type);
+    const tree = readFlowTree(slug);
+    const nodes = walkNodes(tree);
+    const node = nodes.find((candidate) => candidate.id === String(args.node));
+    if (!node) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `No node with id "${args.node}" in "${slug}".`,
+          fix: `Nodes in this form: ${nodes.map((candidate) => `${candidate.id} (${candidate.name})`).join(", ")}`
+        }
+      });
+      process.exit(1);
+    }
+    if (!Array.isArray(node.sideEffects)) node.sideEffects = [];
+    const existing = node.sideEffects;
+    const takenIds = new Set(
+      nodes.flatMap((n) => (n.sideEffects ?? []).map((se) => String(se?.id ?? "")))
+    );
+    const id = args.id ? String(args.id) : freeSideEffectId(type, takenIds);
+    if (takenIds.has(id)) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: `"${slug}" already has a side effect with id "${id}".`,
+          fix: `Drop --id to be given a free one (${freeSideEffectId(type, takenIds)}), or pick another.`
+        }
+      });
+      process.exit(1);
+    }
+    const trigger = resolveTrigger(node, args.trigger ? String(args.trigger) : void 0);
+    if (!trigger.ok) {
+      writeJson({
+        ok: false,
+        error: { code: "VALIDATION_ERROR", message: trigger.message, ...trigger.fix ? { fix: trigger.fix } : {} }
+      });
+      process.exit(1);
+    }
+    const triggerId = trigger.triggerId;
+    const secondPixel = secondPixelHint(node, type, triggerId);
+    const sideEffect = concrete(entry.skeleton, { id, triggerId });
+    existing.push(sideEffect);
+    writeFlowTree(slug, tree);
+    const needsUser = Object.entries(entry.owners ?? {}).filter(([, owner]) => owner !== "agent");
+    writeJson({
+      ok: true,
+      data: { slug, nodeId: node.id, sideEffectId: id, type, triggerId, path: flowDataPath(slug) },
+      hints: [
+        `Fires on \`${triggerId}\` \u2014 the moment "${String(node.name ?? node.id)}" raises. A side effect only runs when its triggerId is the one its own step raises, so this is set from the step, never from the side-effect type.`,
+        // A pixel side effect is the thing most often mistaken for "setting the
+        // conversion". It tells the ad platform; it tells Baker nothing, and a
+        // Form can fire every pixel it has while every Baker report says it
+        // converted nobody.
+        ...needsUser.some(([, owner]) => owner === "tags") ? [
+          `This reports the conversion to ${type}. It does NOT make Baker count anything: what Baker counts is a named event, set with \`baker analytics conversions --flow ${slug}\`. Do both \u2014 they are two different systems asked the same question.`
+        ] : [],
+        ...secondPixel ? [secondPixel] : [],
+        ...configureHints(
+          slug,
+          String(node.id),
+          id,
+          type,
+          needsUser.some(([, owner]) => owner === "request_flow_input" || owner === "connect")
+        ),
+        ...needsUser.some(([, owner]) => owner === "tags") ? [
+          "Fill `tagIds` with a real ref from `baker tags list`, or stage the tag first with the `tags` skill. Never invent one."
+        ] : [],
+        ...entry.gotcha ? [entry.gotcha] : []
+      ]
+    });
+  }
+});
+export {
+  addNodeCommand,
+  addSideEffectCommand,
+  freeSideEffectId,
+  resolveTrigger,
+  sameTrackingSideEffect,
+  secondPixelHint,
+  stepNameRefusal
+};
+//# sourceMappingURL=add-KAMQP5RM.js.map

package/dist/add-Y6QCWI6Q.js

@@ -0,0 +1,104 @@
+import {
+  compactSource,
+  reportError,
+  reportInvalid
+} from "./chunk-ZSRLDTDC.js";
+import {
+  testimonialSourceRefreshIntervalSchema,
+  testimonialSourceTypeSchema,
+  testimonialSourcesAddRequestSchema
+} from "./chunk-MV2J73HP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-I2DNBEV6.js";
+import {
+  apiPost
+} from "./chunk-OSWCEDFE.js";
+import "./chunk-D53AAUG4.js";
+import "./chunk-FZKUUI3F.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4WYEGE4N.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/testimonials/sources/add.ts
+import { defineCommand } from "citty";
+var SITES = testimonialSourceTypeSchema.options.join("|");
+registerSchema({
+  command: "testimonials.sources.add",
+  description: "Add a review page as a testimonial source \u2014 Google Maps, Trustpilot, Yelp, Tripadvisor, G2, Capterra, Amazon, App Store or Google Play. Pass the page's link (it names its own site), or a business name for Google Maps. Its reviews (up to 700) are imported, tagged and made searchable in the background over the next minutes. Each imported review costs a little, so add only the client's own listings the user asked for. Applies immediately and shows on the chat as an already-applied change. Adding a listing that is already a source is a no-op that starts a fresh import.",
+  args: {
+    input: {
+      type: "string",
+      description: "The review page's link, or a business name (Google Maps only)",
+      required: true
+    },
+    platform: {
+      type: "string",
+      description: `Only to force a site: ${SITES}. A bare domain with trustpilot is that company's Trustpilot page.`,
+      required: false
+    },
+    every: {
+      type: "string",
+      description: `Auto-sync cadence: ${testimonialSourceRefreshIntervalSchema.options.join("|")} (default never)`,
+      required: false
+    }
+  }
+});
+function addSourceHints(input, { created, source }) {
+  const hints = [
+    created ? `Added ${source.label} on ${source.platformLabel}. Its reviews are importing in the background \u2014 they become searchable with \`baker testimonials search\` as each one is analysed, usually within a few minutes. Don't wait on them in this turn; check with \`baker testimonials sources list\`.` : `${source.label} on ${source.platformLabel} was already a source; a fresh import was started if one wasn't running.`
+  ];
+  if (created && source.platform === "google" && !/^https?:\/\/|\.[a-z]{2,}\//i.test(input.trim())) {
+    hints.push(
+      `Matched the name to ${source.label} on Google Maps (${source.pageUrl ?? "no link"}). If that is not the client's business, run \`baker testimonials sources remove ${source.id}\` at once and add the listing's Google Maps link instead.`
+    );
+  }
+  if (source.refreshInterval === "never") {
+    hints.push(
+      `Auto-sync is off. If the user wants new reviews to keep arriving: \`baker testimonials sources schedule ${source.id} --every monthly\`.`
+    );
+  }
+  return hints;
+}
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: `Add a review page as a testimonial source. Start here with the page's link; for Google Maps a business name also works.
+
+Examples:
+  baker testimonials sources add https://www.yelp.com/biz/acme-bakery-madrid
+  baker testimonials sources add https://www.g2.com/products/acme --every monthly
+  baker testimonials sources add "Acme Bakery Madrid"          # Google Maps, found by name
+  baker testimonials sources add acme.com --platform trustpilot`
+  },
+  args: {
+    input: { type: "positional", description: "Review page link, or a business name for Google Maps", required: true },
+    platform: { type: "string", description: `Force a site: ${SITES}`, required: false },
+    every: { type: "string", description: "Auto-sync: never|daily|weekly|monthly", required: false }
+  },
+  run: async ({ args }) => {
+    const parsed = testimonialSourcesAddRequestSchema.safeParse({
+      input: String(args.input ?? ""),
+      platform: args.platform ? String(args.platform).toLowerCase().replace(/[\s-]/g, "_") : void 0,
+      every: args.every ? String(args.every).toLowerCase() : void 0
+    });
+    if (!parsed.success) reportInvalid(parsed.error.issues[0]);
+    try {
+      const data = await apiPost("/api/testimonials/sources/add", parsed.data, {
+        timeoutMs: 12e4
+      });
+      const hints = addSourceHints(parsed.data.input, data);
+      writeJson({ ok: true, data: { created: data.created, source: compactSource(data.source) }, hints });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  addCommand,
+  addSourceHints
+};
+//# sourceMappingURL=add-Y6QCWI6Q.js.map

package/dist/add-accounts-M4R7ZVHN.js

@@ -0,0 +1,91 @@
+import {
+  PLATFORM_NAMES,
+  reportError,
+  splitList
+} from "./chunk-4R7H4RV6.js";
+import {
+  apiPost
+} from "./chunk-OSWCEDFE.js";
+import "./chunk-D53AAUG4.js";
+import "./chunk-FZKUUI3F.js";
+import {
+  BRAND_ACCOUNTS_MAX,
+  registerSchema,
+  writeJson
+} from "./chunk-4WYEGE4N.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/add-accounts.ts
+import { defineCommand } from "citty";
+var ADD_TIMEOUT_MS = 12e4;
+var named = (accounts) => accounts.map((a) => `${a.name} (${PLATFORM_NAMES[a.platform]})`).join(", ");
+function addAccountsHints(data) {
+  const hints = [];
+  if (data.added.length > 0) {
+    hints.push(
+      `Now tracking ${named(data.added)} \u2014 its ads arrive over the next minutes; check \`baker winning-ads following\`.`
+    );
+  }
+  if (data.already_tracked.length > 0) {
+    hints.push(`Already tracked under this brand: ${named(data.already_tracked)}.`);
+  }
+  for (const failure of data.failed) {
+    hints.push(`Not added: "${failure.input}" \u2014 ${failure.error}`);
+  }
+  return hints;
+}
+registerSchema({
+  command: "winning-ads.add-accounts",
+  description: "Track more accounts under a brand you already follow \u2014 another country's or language's Facebook page, a second LinkedIn company, another Google Ads entity. Pass the brand's advertiser id and one or more links (comma-separated): profile or ad-library links, Google advertiser ids (AR\u2026), or a website. `follow` returns ready-made calls for the look-alike accounts it found.",
+  args: {
+    advertiser: { type: "string", description: "Advertiser id of a followed brand (from `following`)", required: true },
+    inputs: {
+      type: "string",
+      description: `Comma-separated links, advertiser ids or websites \u2014 up to ${BRAND_ACCOUNTS_MAX}`,
+      required: true
+    }
+  }
+});
+var addAccountsCommand = defineCommand({
+  meta: {
+    name: "add-accounts",
+    description: `Add more of a followed brand's accounts (another market's Facebook page, a second LinkedIn company). Example: baker winning-ads add-accounts adv_123 "https://www.facebook.com/barkibu.it,AR01614014350098432001"`
+  },
+  args: {
+    advertiser: { type: "positional", description: "Advertiser id of a followed brand", required: true },
+    inputs: {
+      type: "positional",
+      description: "Comma-separated links, advertiser ids or websites",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const inputs = [...new Set(splitList(String(args.inputs ?? "")))];
+      if (inputs.length === 0 || inputs.length > BRAND_ACCOUNTS_MAX) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: `Pass between 1 and ${BRAND_ACCOUNTS_MAX} comma-separated links.`
+          }
+        });
+        process.exit(1);
+      }
+      const data = await apiPost(
+        "/api/ad-library/accounts/add",
+        { advertiser_id: String(args.advertiser), inputs },
+        { timeoutMs: ADD_TIMEOUT_MS }
+      );
+      const hints = addAccountsHints(data);
+      writeJson({ ok: true, data, hints: hints.length > 0 ? hints : void 0 });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  addAccountsCommand,
+  addAccountsHints
+};
+//# sourceMappingURL=add-accounts-M4R7ZVHN.js.map

package/dist/ads-6MIIAUFS.js

@@ -0,0 +1,40 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/index.ts
+import { defineCommand } from "citty";
+var adsCommand = defineCommand({
+  meta: {
+    name: "ads",
+    description: `Ad platform commands. Each platform exposes its own native command surface \u2014 no forced parity.
+
+Platforms:
+  google    \u2014 Google Ads (GAQL queries, keywords, accounts, ad library)
+  meta      \u2014 Meta Ads (campaigns, adsets, ads, insights, previews)
+  linkedin  \u2014 LinkedIn Ads (firmographic analytics \u2014 job-title \xD7 company \xD7 industry \xD7 seniority pivots)
+  x         \u2014 X (Twitter) Ads (campaigns, line items, promoted tweets, analytics)
+  chatgpt   \u2014 ChatGPT Ads (account, campaigns, ad groups, ads, insights \u2014 read-only)
+
+Examples:
+  baker ads google accounts
+  baker ads google query --preset campaign-performance --customer-id 1234567890
+  baker ads meta accounts
+  baker ads meta campaigns --account-id act_123 --effective-status ACTIVE
+  baker ads meta insights --object act_123 --level ad --date-preset last_7d --fields impressions,spend,ctr
+  baker ads linkedin accounts
+  baker ads x accounts
+  baker ads x stats sync --preset campaign-engagement-7d --entity-ids abc,def
+  baker ads chatgpt insights --days 30 --granularity daily
+Full guides: __tooling__/docs/tools/baker/ads-<platform>.md (google|meta|linkedin|x|chatgpt)`
+  },
+  subCommands: {
+    google: () => import("./google-44QA3M4N.js").then((m) => m.googleCommand),
+    meta: () => import("./meta-OGB3NB2W.js").then((m) => m.metaCommand),
+    linkedin: () => import("./linkedin-BGZIR43P.js").then((m) => m.linkedinCommand),
+    x: () => import("./x-MDENBZ3X.js").then((m) => m.xCommand),
+    chatgpt: () => import("./chatgpt-RNGSOVHP.js").then((m) => m.chatgptCommand)
+  }
+});
+export {
+  adsCommand
+};
+//# sourceMappingURL=ads-6MIIAUFS.js.map