@koda-sl/baker-cli 0.571.0 → 0.572.0-dev.61ba69c66

package/dist/flows-4ALWJVNF.js

@@ -0,0 +1,340 @@
+import {
+  currentMapping
+} from "./chunk-HUO5MZ7S.js";
+import {
+  collectConfigStatus,
+  collectSideEffects,
+  flowsDir,
+  listFlowSlugs,
+  readFlowTree,
+  readSettings,
+  redactTree,
+  requestFlowInputCall,
+  walkNodes,
+  withSettings
+} from "./chunk-PLIGHRIQ.js";
+import {
+  landingGraphFiles
+} from "./chunk-Z3ENMCFE.js";
+import {
+  FLOW_AGENT_DESTINATION_KINDS,
+  driftRepairHint,
+  flowNodeTriggers
+} from "./chunk-YOHGEF2N.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-IMS53EQU.js";
+import {
+  apiPost
+} from "./chunk-UUDWZIDC.js";
+import "./chunk-S4V2GOKV.js";
+import "./chunk-6LUDG5AB.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-6V4UAC5I.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-BXNL4LKR.js").then((m) => m.schemaCommand),
+    "add-node": () => import("./add-ABPQTO2M.js").then((m) => m.addNodeCommand),
+    "add-side-effect": () => import("./add-ABPQTO2M.js").then((m) => m.addSideEffectCommand),
+    options: () => import("./options-BV3TVUCK.js").then((m) => m.optionsCommand),
+    connect: () => import("./connect-VXEE3QBU.js").then((m) => m.connectCommand),
+    map: () => import("./map-QILMIKS7.js").then((m) => m.mapCommand),
+    normalize: () => import("./normalize-YPQBHWYS.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-4ALWJVNF.js.map

package/dist/follow-N4TKU3UM.js

@@ -0,0 +1,94 @@
+import {
+  PLATFORM_NAMES,
+  reportError
+} from "./chunk-6LNCKT6S.js";
+import {
+  apiPost
+} from "./chunk-UUDWZIDC.js";
+import "./chunk-S4V2GOKV.js";
+import "./chunk-6LUDG5AB.js";
+import {
+  brandAccountInput,
+  registerSchema,
+  writeJson
+} from "./chunk-6V4UAC5I.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/follow.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.follow",
+  description: "Follow a brand so ALL its ads join your library \u2014 every platform (Meta, LinkedIn, TikTok, Google Ads), every account it runs there (one Facebook page per market, each Google entity) and every country. Paste whatever you have: a website (best \u2014 finds every account it links), a brand name, or any profile / ad-library link. Already-in-corpus brands are subscribed instantly; new brands are queued for ingestion. Accounts only named like the brand come back as `suggestions` with a ready `add-accounts` command.",
+  args: {
+    input: {
+      type: "string",
+      description: "Website (best), brand name, or any profile/ad-library link",
+      required: true
+    },
+    label: { type: "string", description: "Optional display label (defaults to the resolved name)", required: false }
+  }
+});
+function followHints(data) {
+  const hints = [];
+  if (data.status === "added") {
+    hints.push(
+      "This brand is new \u2014 we're adding every ad we can find across all platforms and countries. They appear as ingestion completes; check `baker winning-ads following`."
+    );
+  } else if (data.status === "ambiguous") {
+    hints.push(
+      "Multiple brands matched. Pick one from `candidates` and re-run `follow` with its exact website or link."
+    );
+  }
+  const suggestions = data.suggestions ?? [];
+  const names = suggestions.map((s) => `${s.name} (${PLATFORM_NAMES[s.platform]})`).join(", ");
+  if (data.status === "unconfirmed") {
+    const [first] = suggestions;
+    hints.push(
+      `Nothing followed yet: we found no account we're sure is this brand's, only accounts named like it: ${names}. Follow the brand's own with its link, e.g. baker winning-ads follow "${first ? brandAccountInput(first) : ""}", then add its other markets' accounts with \`add-accounts\`. Or retry with the brand's website.`
+    );
+    return hints;
+  }
+  if (data.advertiser && suggestions.length > 0) {
+    const inputs = suggestions.map(brandAccountInput).join(",");
+    hints.push(
+      `Also found accounts named like this brand, not tracked yet: ${names}. If they are the same brand (another country or language), track them with: baker winning-ads add-accounts ${data.advertiser.advertiser_id} "${inputs}" \u2014 drop any that belong to someone else.`
+    );
+  }
+  return hints.length > 0 ? hints : void 0;
+}
+var followCommand = defineCommand({
+  meta: {
+    name: "follow",
+    description: 'Follow a brand to track ALL its ads \u2014 every platform, every account and country. Paste a website (best), a brand name, or any profile/ad-library link. Example: baker winning-ads follow "barkibu.com"'
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Website (best), brand name, or any profile/ad-library link",
+      required: true
+    },
+    label: { type: "string", description: "Optional display label", required: false },
+    platform: {
+      type: "string",
+      description: "Ignored \u2014 every platform is searched. Kept so older commands still run.",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = { input: String(args.input) };
+      if (args.label) {
+        body.label = String(args.label);
+      }
+      const data = await apiPost("/api/ad-library/follow", body);
+      writeJson({ ok: true, data, hints: followHints(data) });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  followCommand,
+  followHints
+};
+//# sourceMappingURL=follow-N4TKU3UM.js.map

package/dist/follow-competitors-AHQ57BWS.js

@@ -0,0 +1,112 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-6LNCKT6S.js";
+import {
+  apiPost
+} from "./chunk-UUDWZIDC.js";
+import "./chunk-S4V2GOKV.js";
+import "./chunk-6LUDG5AB.js";
+import {
+  FOLLOW_BATCH_MAX,
+  registerSchema,
+  writeJson
+} from "./chunk-6V4UAC5I.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/follow-competitors.ts
+import { defineCommand } from "citty";
+var BATCH_TIMEOUT_MS = 3e5;
+function buildFollowBatchBody(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const inputs = [];
+  for (const domain of splitList(input.domains)) {
+    const key = domain.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    inputs.push(domain);
+  }
+  return { inputs };
+}
+registerSchema({
+  command: "winning-ads.follow-competitors",
+  description: "Follow MANY brands at once \u2014 the fast way to add every competitor to your library. Pass a comma-separated list of domains (best \u2014 each resolves every platform and every account we can find, every country). One brand failing never blocks the others: the response reports per-brand status (following/added/ambiguous/failed) plus rollup counts. Ideal right after a competitor scan.",
+  args: {
+    domains: {
+      type: "string",
+      description: `Comma-separated domains (best), profile/ad-library URLs, or brand names \u2014 up to ${FOLLOW_BATCH_MAX}. e.g. "deel.com,notion.so,hubspot.com"`,
+      required: true
+    }
+  }
+});
+var followCompetitorsCommand = defineCommand({
+  meta: {
+    name: "follow-competitors",
+    description: 'Follow many brands at once by domain \u2014 add every competitor in one call. Example: baker winning-ads follow-competitors "deel.com,notion.so,hubspot.com"'
+  },
+  args: {
+    domains: {
+      type: "positional",
+      description: "Comma-separated domains (best), URLs, or brand names",
+      required: true
+    },
+    platform: {
+      type: "string",
+      description: "Ignored \u2014 every platform is searched. Kept so older commands still run.",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = buildFollowBatchBody({ domains: String(args.domains ?? "") });
+      if (body.inputs.length === 0) {
+        writeJson({
+          ok: false,
+          error: { code: "VALIDATION_ERROR", message: "Pass at least one domain in --domains." }
+        });
+        process.exit(1);
+      }
+      if (body.inputs.length > FOLLOW_BATCH_MAX) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: `Too many brands (${body.inputs.length}). Follow at most ${FOLLOW_BATCH_MAX} per call.`
+          }
+        });
+        process.exit(1);
+      }
+      const data = await apiPost("/api/ad-library/follow-batch", body, {
+        timeoutMs: BATCH_TIMEOUT_MS
+      });
+      const hints = [];
+      if (data.failed_count > 0) {
+        const failed = data.results.filter((r) => r.status === "failed").map((r) => r.input);
+        hints.push(
+          `${data.failed_count} brand(s) couldn't be added: ${failed.join(", ")}. Retry each with its website or Facebook/LinkedIn URL via \`baker winning-ads follow\`.`
+        );
+      }
+      if (data.ambiguous_count > 0) {
+        const ambiguous = data.results.filter((r) => r.status === "ambiguous").map((r) => r.input);
+        hints.push(
+          `${data.ambiguous_count} brand(s) matched multiple advertisers: ${ambiguous.join(", ")}. Re-run \`baker winning-ads follow\` with an exact domain/URL to pick one.`
+        );
+      }
+      if (data.added_count > 0) {
+        hints.push(
+          "Newly added brands are ingesting now \u2014 their winners fill in over the next few minutes. Check `baker winning-ads following` or `baker winning-ads feed`."
+        );
+      }
+      writeJson({ ok: true, data, hints: hints.length > 0 ? hints : void 0 });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  buildFollowBatchBody,
+  followCompetitorsCommand
+};
+//# sourceMappingURL=follow-competitors-AHQ57BWS.js.map

package/dist/following-CEYH33DW.js

@@ -0,0 +1,113 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-6LNCKT6S.js";
+import {
+  apiGet
+} from "./chunk-UUDWZIDC.js";
+import "./chunk-S4V2GOKV.js";
+import "./chunk-6LUDG5AB.js";
+import {
+  applyFieldMask,
+  registerSchema,
+  writeJson,
+  writeOutput
+} from "./chunk-6V4UAC5I.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/following.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.following",
+  description: "List the brands you follow in your ad-dna library, with each one's status (ready vs still adding) and cached ad counts. A brand still adding has counts that are a lie in progress; one with `discovery_failed` has counts that are short because we couldn't finish looking, which is not the same as it running no ads.",
+  args: {}
+});
+function displayStatus(status) {
+  return status === "ready" ? "ready" : "adding\u2026";
+}
+function compactFollowed(record) {
+  return {
+    followed_id: String(record.followed_id ?? ""),
+    advertiser_id: String(record.advertiser_id ?? ""),
+    label: String(record.label ?? ""),
+    status: displayStatus(record.status),
+    active_ad_count: record.active_ad_count ?? null,
+    total_ad_count: record.total_ad_count ?? null,
+    family_count: record.family_count ?? null,
+    adding_discovered: record.adding_discovered ?? null,
+    adding_enqueued: record.adding_enqueued ?? null,
+    adding_ingested: record.adding_ingested ?? null,
+    // Without this a brand we failed to finish looking at is indistinguishable
+    // from one that genuinely runs no ads — both read `ready` with 0 ads.
+    discovery_failed: record.discovery_failed ?? null
+  };
+}
+function followingHints(records) {
+  const hints = [];
+  const label = (r) => String(r.label ?? r.advertiser_id ?? "");
+  const incomplete = records.filter((r) => r.discovery_failed === true && r.status !== "adding\u2026");
+  if (incomplete.length > 0) {
+    hints.push(
+      `${incomplete.length} brand(s) couldn't be fully added: ${incomplete.map(label).join(", ")}. Their counts are incomplete \u2014 re-run \`baker winning-ads follow <domain>\` for each to try again.`
+    );
+  }
+  const adding = records.filter((r) => r.status === "adding\u2026");
+  if (adding.length > 0) {
+    hints.push(
+      `${adding.length} brand(s) are still being added: ${adding.map(label).join(", ")}. Their ad counts fill in over the next few minutes \u2014 don't report them as final, and don't re-follow to speed it up.`
+    );
+  }
+  return hints;
+}
+function followingNormalizer(record, full) {
+  const compact = compactFollowed(record);
+  if (!full) {
+    return compact;
+  }
+  return {
+    ...compact,
+    image_url: record.image_url ?? null,
+    platforms: Array.isArray(record.platforms) ? record.platforms : []
+  };
+}
+var followingCommand = defineCommand({
+  meta: {
+    name: "following",
+    description: "List brands you follow, with status (ready / adding\u2026) and cached counts. A brand's counts are only final once it is ready. Example: baker winning-ads following --output md"
+  },
+  args: {
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include image + platforms", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const data = await apiGet("/api/ad-library/following");
+      const output = args.output || "json";
+      const full = args.full;
+      const rawList = Array.isArray(data?.following) ? data.following : [];
+      const following = rawList.map((f) => followingNormalizer(f, full));
+      const hints = followingHints(following);
+      if (output === "json") {
+        const fields = splitList(args.fields);
+        const rows = fields.length > 0 ? following.map((f) => applyFieldMask(f, fields)) : following;
+        writeJson({ ok: true, data: { following: rows }, hints: hints.length > 0 ? hints : void 0 });
+        return;
+      }
+      writeOutput(
+        { ok: true, data: rawList, hints: hints.length > 0 ? hints : void 0 },
+        output,
+        args.fields ? args.fields.split(",") : void 0,
+        full,
+        followingNormalizer
+      );
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  followingCommand,
+  followingHints
+};
+//# sourceMappingURL=following-CEYH33DW.js.map