@koda-sl/baker-cli 0.457.0 → 0.458.0

package/dist/fetch-QIHGIATQ.js

@@ -0,0 +1,176 @@
+import {
+  fetchHints,
+  redditPageFix
+} from "./chunk-XX5DXKEI.js";
+import {
+  handleResearchError,
+  writeResearchJson
+} from "./chunk-N3DLCXMB.js";
+import "./chunk-ZJVHZHYP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-VAOMHPEX.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost
+} from "./chunk-TOYLG3ZY.js";
+import "./chunk-E4ICSNSW.js";
+import "./chunk-YKSIHGIL.js";
+import {
+  registerSchema
+} from "./chunk-ZZFYDAJQ.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/research/fetch.ts
+import { defineCommand } from "citty";
+var CONTENT_PREVIEW_CHARS = 2e4;
+var TIMEOUT_MS = 18e4;
+registerSchema({
+  command: "research.fetch",
+  description: "Read a page an ordinary web fetch could not \u2014 bot walls and JavaScript-rendered pages are resolved for you. Use it when your normal page read came back with a security check, an error page, or an empty shell.",
+  args: {
+    url: { type: "string", description: "Full URL of the page to read", required: true },
+    format: {
+      type: "string",
+      description: "markdown (default, best for reading) or html (when you need the markup)",
+      required: false,
+      enum: ["markdown", "html"]
+    },
+    "wait-for": {
+      type: "number",
+      description: "Extra ms to let late content settle (0-30000). Only for pages that fill in after load",
+      required: false
+    },
+    "whole-page": {
+      type: "boolean",
+      description: "Include nav, footer and sidebars (default: main content only)",
+      required: false,
+      default: false
+    },
+    full: {
+      type: "boolean",
+      description: `Return the whole page instead of the first ${CONTENT_PREVIEW_CHARS} characters`,
+      required: false,
+      default: false
+    }
+  }
+});
+var FIELDS = {
+  url: "The URL as asked for",
+  final_url: "Where the read landed after redirects",
+  title: "Page title, or null when the page declares none",
+  content: "The page text (markdown by default)",
+  content_chars: "Length of the full page available on the server",
+  content_shown: "Characters in `content` \u2014 below content_chars unless --full",
+  truncated: "The page was longer than one read returns, so the tail is missing",
+  provider: "Who resolved the read"
+};
+function fetchFix(code) {
+  if (code === "VALIDATION_ERROR") {
+    return {
+      action: "retry_with_changes",
+      explanation: "Re-run with a complete address, including https://."
+    };
+  }
+  if (code === "TIMEOUT") {
+    return {
+      action: "retry_with_changes",
+      explanation: "The page never settled. Retry this URL once with `--wait-for 10000`; if that fails too, carry on with the rest of the job and say this page couldn't be read."
+    };
+  }
+  if (code === "RATE_LIMITED") {
+    return {
+      action: "continue_without",
+      explanation: "The page reader is busy. Do the rest of the job first and come back to this URL once, later \u2014 don't loop on it."
+    };
+  }
+  if (code === "FORBIDDEN" || code === "NOT_FOUND") {
+    return {
+      action: "continue_without",
+      explanation: "This page will not open for us, and retrying will not change that. Carry on with the sources you can reach and say plainly which page you couldn't read."
+    };
+  }
+  return {
+    action: "continue_without",
+    explanation: "This read failed. Don't build a retry ladder around it \u2014 finish the rest of the job with what you can reach and name this page as a gap."
+  };
+}
+var fetchCommand = defineCommand({
+  meta: {
+    name: "fetch",
+    description: `Read a page an ordinary web fetch could not. Bot walls and JavaScript-rendered pages are resolved for you \u2014 you never have to retry, wait, or drive a browser yourself.
+
+Reach for this the moment a normal page read comes back with a security check, an error page, or an empty shell. One call, no escalation ladder.
+
+Examples:
+  baker research fetch "https://competitor.com/pricing"
+  baker research fetch "https://competitor.com/pricing" --full
+  baker research fetch "https://app.competitor.com/blog/post" --wait-for 5000
+  baker research fetch "https://competitor.com" --format html --whole-page`
+  },
+  args: {
+    url: { type: "positional", description: "URL of the page to read", required: false },
+    format: { type: "string", description: "markdown (default) or html", required: false },
+    "wait-for": { type: "string", description: "Extra ms to let late content settle (0-30000)", required: false },
+    "whole-page": { type: "boolean", description: "Include nav, footer and sidebars", required: false },
+    full: { type: "boolean", description: "Return the whole page, not just the first chunk", required: false }
+  },
+  run: async ({ args }) => {
+    const url = args.url;
+    if (!url) {
+      writeResearchJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: "A URL is required",
+          fix: fetchFix("VALIDATION_ERROR")
+        }
+      });
+      process.exit(1);
+    }
+    const format = args.format ?? "markdown";
+    if (format !== "markdown" && format !== "html") {
+      writeResearchJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: "Format must be markdown or html",
+          fix: { action: "retry_with_changes", explanation: "Re-run with --format markdown or --format html." }
+        }
+      });
+      process.exit(1);
+    }
+    const body = { url, format };
+    if (args["wait-for"]) body.waitFor = Number(args["wait-for"]);
+    if (args["whole-page"]) body.onlyMainContent = false;
+    try {
+      const page = await apiPost("/api/research/fetch", body, { timeoutMs: TIMEOUT_MS });
+      const content = args.full ? page.content : page.content.slice(0, CONTENT_PREVIEW_CHARS);
+      writeResearchJson({
+        ok: true,
+        data: {
+          url: page.url,
+          final_url: page.finalUrl,
+          title: page.title,
+          content_chars: page.contentChars,
+          content_shown: content.length,
+          truncated: page.truncated,
+          provider: page.provider,
+          content
+        },
+        fields: FIELDS,
+        hints: fetchHints({
+          truncated: page.truncated,
+          contentChars: page.contentChars,
+          shownChars: content.length
+        })
+      });
+    } catch (err) {
+      handleResearchError(err, (code) => redditPageFix(url, code) ?? fetchFix(code));
+    }
+  }
+});
+export {
+  fetchCommand
+};
+//# sourceMappingURL=fetch-QIHGIATQ.js.map

package/dist/find-SLZO4FBR.js

@@ -0,0 +1,134 @@
+import {
+  OUTPUT_ARGS,
+  writeProviderHits
+} from "./chunk-6R7CMUIZ.js";
+import {
+  AUTO_INGEST_MAX,
+  parseAutoIngest
+} from "./chunk-KKJ4KJCW.js";
+import {
+  emptyResultHints
+} from "./chunk-Q6ULQMWG.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-TOYLG3ZY.js";
+import "./chunk-E4ICSNSW.js";
+import "./chunk-YKSIHGIL.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-ZZFYDAJQ.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/find.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.find",
+  description: "Fanout image search: library first, then opted-in external providers.",
+  args: {
+    query: { type: "string", description: "Search query", required: true },
+    sources: {
+      type: "string",
+      description: "Comma-separated providers: library,pexels,pixabay,google,iconify,giphy,pinterest (brandfetch lives at `baker images logo`)",
+      required: false
+    },
+    limit: { type: "number", description: "Max results per group", required: false, default: 20 },
+    fallback: {
+      type: "boolean",
+      description: "Only cascade to externals when top library score < threshold",
+      required: false,
+      default: false
+    },
+    threshold: { type: "number", description: "Fallback threshold (0-1)", required: false, default: 0.4 },
+    "auto-ingest": {
+      type: "number",
+      description: `Auto-ingest top N external hits (0-${AUTO_INGEST_MAX.find}, default 0) and return Baker-owned URLs on ingested hits`,
+      required: false,
+      default: 0
+    },
+    context: {
+      type: "string",
+      description: "Free-text hint applied to every auto-ingested hit (overrides provider-derived context)",
+      required: false
+    },
+    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 full metadata", required: false, default: false }
+  }
+});
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Library-first fanout image search. Opt in to providers with --sources. `--fallback` short-circuits to externals only when library is thin. With --auto-ingest, ingested external hits return Baker-owned URLs.\n\nExample: baker images find 'office' --sources library,pexels --limit 20"
+  },
+  args: {
+    query: { type: "positional", description: "Search query", required: false },
+    sources: { type: "string", description: "Comma-separated providers", required: false },
+    limit: { type: "string", description: "Max results per group (default 20)", required: false },
+    fallback: { type: "boolean", description: "Cascade to externals only when library thin", required: false },
+    threshold: { type: "string", description: "Fallback threshold (default 0.4)", required: false },
+    "auto-ingest": {
+      type: "string",
+      description: `Auto-ingest top N external hits (0-${AUTO_INGEST_MAX.find}) and return Baker-owned URLs on ingested hits`,
+      required: false
+    },
+    context: { type: "string", description: "Description context hint applied to auto-ingested hits", required: false },
+    ...OUTPUT_ARGS
+  },
+  run: async ({ args }) => {
+    try {
+      const query = args.query;
+      if (!query) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Query is required" } });
+        process.exit(1);
+      }
+      const body = { query };
+      if (args.sources) {
+        body.sources = args.sources.split(",").filter(Boolean);
+      }
+      if (args.limit) body.limit = Number(args.limit);
+      if (args.fallback) body.fallback = true;
+      if (args.threshold) body.threshold = Number(args.threshold);
+      if (args["auto-ingest"] !== void 0) {
+        const parsed = parseAutoIngest(args["auto-ingest"], AUTO_INGEST_MAX.find);
+        if (!parsed.ok) {
+          writeJson({
+            ok: false,
+            error: {
+              code: "VALIDATION_ERROR",
+              message: parsed.message,
+              fix: {
+                action: "retry_with_changes",
+                explanation: `Re-run with --auto-ingest in 0-${AUTO_INGEST_MAX.find}.`
+              }
+            }
+          });
+          process.exit(1);
+        }
+        body.autoIngest = parsed.value;
+      }
+      if (args.context) body.descriptionContext = args.context;
+      const data = await apiPost("/api/images/find", body);
+      const hits = [...data.groups.library, ...data.groups.external];
+      const hints = emptyResultHints({
+        provider: "find",
+        hitCount: hits.length,
+        activeFilters: args.fallback ? ["--fallback"] : [],
+        subject: query
+      });
+      writeProviderHits(data, hits, args, hints);
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson({ ok: false, error: { code: err.code, message: err.message } });
+        process.exit(1);
+      }
+      writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  findCommand
+};
+//# sourceMappingURL=find-SLZO4FBR.js.map

package/dist/fit-SSR3JDDI.js

@@ -0,0 +1,45 @@
+import {
+  FitAnswerSchema,
+  NO_FIT_HINT,
+  buildFitPrompt,
+  conceptFromFit,
+  fitCachePath,
+  fitCommand,
+  fitHints,
+  fitOnce,
+  fitReference,
+  readCachedFit,
+  readKnowledge,
+  reviewsForFit
+} from "./chunk-IFZD2MDE.js";
+import "./chunk-RIXGQIMZ.js";
+import "./chunk-73JXX4LJ.js";
+import "./chunk-5TOKIRCD.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-KYQZM5FB.js";
+import "./chunk-CHSNHVYF.js";
+import "./chunk-KNX2UBLI.js";
+import "./chunk-5URIFBIL.js";
+import "./chunk-3KN3VCS3.js";
+import "./chunk-LCMGWIEQ.js";
+import "./chunk-HMKVVPWY.js";
+import "./chunk-TOYLG3ZY.js";
+import "./chunk-E4ICSNSW.js";
+import "./chunk-YKSIHGIL.js";
+import "./chunk-ZZFYDAJQ.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  FitAnswerSchema,
+  NO_FIT_HINT,
+  buildFitPrompt,
+  conceptFromFit,
+  fitCachePath,
+  fitCommand,
+  fitHints,
+  fitOnce,
+  fitReference,
+  readCachedFit,
+  readKnowledge,
+  reviewsForFit
+};
+//# sourceMappingURL=fit-SSR3JDDI.js.map

package/dist/flows-IRFHGBUR.js

@@ -0,0 +1,247 @@
+import {
+  collectConfigStatus,
+  collectSideEffects,
+  listFlowSlugs,
+  readFlowTree,
+  readSettings,
+  redactTree,
+  requestFlowInputCall,
+  withSettings
+} from "./chunk-EIAA3XTT.js";
+import {
+  FLOW_AGENT_DESTINATION_KINDS,
+  driftRepairHint,
+  flowNodeTriggers
+} from "./chunk-ZJVHZHYP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-VAOMHPEX.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost
+} from "./chunk-TOYLG3ZY.js";
+import "./chunk-E4ICSNSW.js";
+import "./chunk-YKSIHGIL.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-ZZFYDAJQ.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 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-JJVSWKGP.js").then((m) => m.schemaCommand),
+    "add-node": () => import("./add-7P4VYS7R.js").then((m) => m.addNodeCommand),
+    "add-side-effect": () => import("./add-7P4VYS7R.js").then((m) => m.addSideEffectCommand),
+    options: () => import("./options-FTXE6HFT.js").then((m) => m.optionsCommand),
+    connect: () => import("./connect-4WXSJAIK.js").then((m) => m.connectCommand),
+    map: () => import("./map-NNMEQE6E.js").then((m) => m.mapCommand),
+    normalize: () => import("./normalize-OTNIBYUO.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-IRFHGBUR.js.map

package/dist/follow-EKNBOS7Z.js

@@ -0,0 +1,82 @@
+import {
+  reportError
+} from "./chunk-3FOE4P6A.js";
+import {
+  adLibraryPlatformSchema
+} from "./chunk-VAOMHPEX.js";
+import {
+  apiPost
+} from "./chunk-TOYLG3ZY.js";
+import "./chunk-E4ICSNSW.js";
+import "./chunk-YKSIHGIL.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-ZZFYDAJQ.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/follow.ts
+import { defineCommand } from "citty";
+var PLATFORMS = adLibraryPlatformSchema.options;
+registerSchema({
+  command: "winning-ads.follow",
+  description: "Follow a brand so ALL its ads join your library \u2014 every platform (Meta, LinkedIn, TikTok, Google Ads) and every country. Pass a domain (best \u2014 resolves every platform), an ad-library / profile URL (a Google Ads Transparency Center link works), or a brand name. --platform tells us how to read your input; it does NOT limit what we track. Already-in-corpus brands are subscribed instantly; new brands are queued for ingestion.",
+  args: {
+    input: { type: "string", description: "Domain (best), profile/ad-library URL, or brand name", required: true },
+    platform: {
+      type: "string",
+      description: "meta|linkedin|tiktok|google \u2014 how to read the input, not a tracking limit. We track every platform we can resolve.",
+      required: true
+    },
+    label: { type: "string", description: "Optional display label (defaults to the resolved name)", required: false }
+  }
+});
+var followCommand = defineCommand({
+  meta: {
+    name: "follow",
+    description: 'Follow a brand to track ALL its ads \u2014 every platform and country. --platform is how we read your input, not a limit. A domain tracks every platform we can resolve. Example: baker winning-ads follow "deel.com" --platform meta'
+  },
+  args: {
+    input: { type: "positional", description: "Domain (best), profile/ad-library URL, or brand name", required: true },
+    platform: {
+      type: "string",
+      description: "meta|linkedin|tiktok|google \u2014 how to read the input, not a tracking limit.",
+      required: true
+    },
+    label: { type: "string", description: "Optional display label", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const platform = String(args.platform ?? "");
+      if (!PLATFORMS.includes(platform)) {
+        writeJson({
+          ok: false,
+          error: { code: "VALIDATION_ERROR", message: `--platform must be one of: ${PLATFORMS.join(", ")}` }
+        });
+        process.exit(1);
+      }
+      const body = { input: String(args.input), platform };
+      if (args.label) {
+        body.label = String(args.label);
+      }
+      const data = await apiPost("/api/ad-library/follow", body);
+      let hints;
+      if (data.status === "added") {
+        hints = [
+          "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 = [
+          "Multiple brands matched. Pick one from `candidates` and re-run `follow` with its exact domain/URL, or follow the specific advertiser id."
+        ];
+      }
+      writeJson({ ok: true, data, hints });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  followCommand
+};
+//# sourceMappingURL=follow-EKNBOS7Z.js.map