@koda-sl/baker-cli 0.512.0 → 0.514.0

package/dist/chunk-NB2FU6EZ.js

@@ -0,0 +1,179 @@
+import {
+  CHECKOUT_RECORD_REFUSAL,
+  CONVERSION_COUNT_MODES,
+  findNameCollision,
+  isCheckoutRecordKey,
+  isLandingViewKey,
+  parseEventKey
+} from "./chunk-JOE42ZW6.js";
+
+// src/commands/analytics/conversionArgs.ts
+var ConversionArgsError = class extends Error {
+  constructor(message, fix) {
+    super(message);
+    this.fix = fix;
+  }
+};
+function allValues(flag, argv) {
+  const values = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === flag) {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) values.push(next);
+      continue;
+    }
+    if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
+  }
+  return values.map((value) => value.trim()).filter((value) => value !== "");
+}
+function onlyOnce(value, flag, argv) {
+  if (value === void 0) return void 0;
+  const given = argv.filter((arg) => arg === flag || arg.startsWith(`${flag}=`)).length;
+  if (given > 1) {
+    throw new ConversionArgsError(
+      `${flag} was given ${given} times and only the last would have been used. It takes one value.`
+    );
+  }
+  const trimmed = String(value).trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function repeatable(flag, cittyValue, argv) {
+  const fromArgv = allValues(flag, argv);
+  if (fromArgv.length > 0) return fromArgv;
+  if (cittyValue === void 0) return [];
+  const trimmed = String(cittyValue).trim();
+  return trimmed === "" ? [] : [trimmed];
+}
+function checkFlagShape(args) {
+  if (args.eventKeys.length > 0 && args.name === void 0 && args.countMode === void 0) {
+    throw new ConversionArgsError(
+      "--event needs --name: a conversion nobody named is a row labelled with a UUID. (--event with only --count-mode changes how an event already counted is counted.)"
+    );
+  }
+  if (args.name !== void 0 && args.eventKeys.length === 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError("--name needs --event, naming which event to count.");
+  }
+  if (args.renameFrom !== void 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError('--rename needs --to: `--rename "Lead form" --to "Lead"`.');
+  }
+  if (args.renameTo !== void 0 && args.renameFrom === void 0) {
+    throw new ConversionArgsError(
+      '--to needs --rename, naming which outcome to rename: `--rename "Lead form" --to "Lead"`.'
+    );
+  }
+}
+function checkEventKeys(eventKeys) {
+  for (const eventKey of eventKeys) {
+    if (parseEventKey(eventKey) === null) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not an event key. Run with --candidates (or --flow <slug> for one Form) and copy one; they look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or exit:<host>.`
+      );
+    }
+    if (isLandingViewKey(eventKey)) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is a landing being viewed \u2014 a funnel step, never a conversion. Add it as a step with \`baker funnel\` instead.`
+      );
+    }
+    if (isCheckoutRecordKey(eventKey)) {
+      throw new ConversionArgsError(CHECKOUT_RECORD_REFUSAL.message, CHECKOUT_RECORD_REFUSAL.fix);
+    }
+  }
+}
+function readDays(raw) {
+  if (raw === void 0) return void 0;
+  const days = Number(raw);
+  if (!Number.isFinite(days) || days <= 0) {
+    throw new ConversionArgsError("--days must be a positive number of days.");
+  }
+  return days;
+}
+function parseConversionsArgs(raw, argv) {
+  const countMode = onlyOnce(raw["count-mode"], "--count-mode", argv);
+  if (countMode !== void 0 && !CONVERSION_COUNT_MODES.includes(countMode)) {
+    throw new ConversionArgsError(`--count-mode must be one of ${CONVERSION_COUNT_MODES.join(", ")}.`);
+  }
+  const args = {
+    eventKeys: repeatable("--event", raw.event, argv),
+    removeKeys: repeatable("--remove", raw.remove, argv),
+    name: onlyOnce(raw.name, "--name", argv),
+    countMode,
+    renameFrom: onlyOnce(raw.rename, "--rename", argv),
+    renameTo: onlyOnce(raw.to, "--to", argv),
+    removeName: onlyOnce(raw["remove-name"], "--remove-name", argv),
+    flowSlug: onlyOnce(raw.flow, "--flow", argv),
+    candidates: raw.candidates === true,
+    full: raw.full === true,
+    days: readDays(raw.days)
+  };
+  checkFlagShape(args);
+  checkEventKeys(args.eventKeys);
+  return args;
+}
+function existingNames(existing) {
+  return [...new Set(existing.map((row) => row.name))];
+}
+function checkNameCollision(name, existing) {
+  const collision = findNameCollision(name, existingNames(existing));
+  if (collision === null) return;
+  throw new ConversionArgsError(
+    `This company already counts "${collision}", and "${name}" would be a second row for the same outcome \u2014 Baker groups by exact name, so the number would be split in two. Use "${collision}" to make them one number, or pick a name that means something different.`
+  );
+}
+function under(name, existing) {
+  const rows = existing.filter((row) => row.name === name);
+  if (rows.length === 0) {
+    throw new ConversionArgsError(
+      `Nothing is counted under "${name}". This company counts: ${existingNames(existing).join(", ") || "nothing yet"}.`
+    );
+  }
+  return rows;
+}
+function setFromEvents(args, existing) {
+  if (args.eventKeys.length === 0) return [];
+  if (args.name !== void 0) {
+    checkNameCollision(args.name, existing);
+    const name = args.name;
+    return args.eventKeys.map((eventKey) => ({
+      eventKey,
+      name,
+      ...args.countMode ? { countMode: args.countMode } : {}
+    }));
+  }
+  return args.eventKeys.map((eventKey) => {
+    const current = existing.find((row) => row.eventKey === eventKey);
+    if (!current) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not counted, so there is no count mode to change. Add it with --event "${eventKey}" --name "<what a person calls it>" --count-mode ${args.countMode}.`
+      );
+    }
+    return { eventKey, name: current.name, countMode: args.countMode };
+  });
+}
+function setFromRename(args, existing) {
+  if (args.renameFrom === void 0 || args.renameTo === void 0) return [];
+  const renameTo = args.renameTo;
+  checkNameCollision(renameTo, existing);
+  return under(args.renameFrom, existing).map((row) => ({
+    eventKey: row.eventKey,
+    name: renameTo,
+    countMode: row.countMode
+  }));
+}
+function conversionsWrite(args, existing) {
+  const set = [...setFromEvents(args, existing), ...setFromRename(args, existing)];
+  const remove = [
+    ...args.removeKeys,
+    ...args.removeName === void 0 ? [] : under(args.removeName, existing).map((row) => row.eventKey)
+  ];
+  if (set.length === 0 && remove.length === 0) return null;
+  return { ...set.length > 0 ? { set } : {}, ...remove.length > 0 ? { remove } : {} };
+}
+
+export {
+  ConversionArgsError,
+  onlyOnce,
+  parseConversionsArgs,
+  conversionsWrite
+};
+//# sourceMappingURL=chunk-NB2FU6EZ.js.map

package/dist/chunk-NKQWDEB7.js

@@ -0,0 +1,115 @@
+import {
+  MATCH_FIELDS
+} from "./chunk-G4FG5EQO.js";
+
+// ../api/src/event-ingest/vocabulary.ts
+var INGEST_CLICK_ID_PARAMS = [
+  "gclid",
+  "wbraid",
+  "gbraid",
+  "dclid",
+  "fbclid",
+  "ttclid",
+  "twclid",
+  "li_fat_id",
+  "msclkid",
+  "rdt_cid",
+  "epik",
+  "sccid",
+  "oppref"
+];
+
+// ../api/src/event-sources/fields.ts
+var MATCH_LABELS = {
+  first_name: "First name",
+  last_name: "Last name",
+  date_of_birth: "Date of birth",
+  gender: "Gender",
+  city: "City",
+  region: "Region",
+  postal_code: "Postcode",
+  country: "Country"
+};
+var CLICK_LABELS = {
+  gclid: "Google click id",
+  wbraid: "Google click id (iOS, web to app)",
+  gbraid: "Google click id (iOS, app)",
+  dclid: "Google click id (Display & Video)",
+  fbclid: "Meta click id",
+  ttclid: "TikTok click id",
+  twclid: "X click id",
+  li_fat_id: "LinkedIn click id",
+  msclkid: "Microsoft click id",
+  rdt_cid: "Reddit click id",
+  epik: "Pinterest click id",
+  sccid: "Snapchat click id",
+  oppref: "ChatGPT Ads click id"
+};
+var SOURCE_FIELDS = [
+  { field: "event_name", label: "What happened", group: "event" },
+  { field: "event_time", label: "When it happened", group: "event" },
+  { field: "event_id", label: "Its id", group: "event" },
+  { field: "email", label: "Email", group: "person" },
+  { field: "phone", label: "Phone", group: "person" },
+  { field: "external_id", label: "Your own id for the person", group: "person" },
+  ...MATCH_FIELDS.map((field) => ({ field, label: MATCH_LABELS[field], group: "person" })),
+  { field: "value", label: "Amount", group: "money" },
+  { field: "currency", label: "Currency", group: "money" },
+  ...INGEST_CLICK_ID_PARAMS.map((field) => ({ field, label: CLICK_LABELS[field], group: "click" }))
+];
+var SOURCE_FIELD_NAMES = SOURCE_FIELDS.map((spec) => spec.field);
+var FIELD_SET = new Set(SOURCE_FIELD_NAMES);
+function isSourceField(value) {
+  return FIELD_SET.has(value);
+}
+var PROPERTY_ROW_PREFIX = "properties.";
+var PROPERTY_KEY_MAX = 64;
+var PROPERTY_KEY = /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/;
+var RESERVED_PROPERTY_KEYS = ["baker_source", "hubspot_property", "hubspot_value"];
+function isPropertyRow(row) {
+  return row.startsWith(PROPERTY_ROW_PREFIX);
+}
+function propertyKeyOf(row) {
+  return isPropertyRow(row) ? row.slice(PROPERTY_ROW_PREFIX.length) : null;
+}
+function propertyKeyProblem(key) {
+  const trimmed = key.trim();
+  if (trimmed === "") return "A property needs a name.";
+  if (trimmed.length > PROPERTY_KEY_MAX) return `A property name is at most ${PROPERTY_KEY_MAX} characters.`;
+  if (!PROPERTY_KEY.test(trimmed)) {
+    return `"${trimmed}" is not a property name: letters, digits, underscore, dash and dot only, starting with a letter or digit.`;
+  }
+  if (RESERVED_PROPERTY_KEYS.includes(trimmed)) return `"${trimmed}" is written by Baker itself; pick another name.`;
+  return null;
+}
+function mappingRowProblem(row) {
+  if (isSourceField(row)) return null;
+  const key = propertyKeyOf(row);
+  if (key === null) {
+    return `"${row}" is not a field an event can carry. A field is one of ${SOURCE_FIELD_NAMES.join(", ")}; an extra property is spelled properties.<name>.`;
+  }
+  return propertyKeyProblem(key);
+}
+
+// ../api/src/event-sources/template.ts
+var MENTION = /\{\{\s*([^{}]+?)\s*\}\}/g;
+function mentionOf(path) {
+  return `{{${path}}}`;
+}
+function templateMentions(template) {
+  const seen = [];
+  for (const match of template.matchAll(MENTION)) {
+    const path = (match[1] ?? "").trim();
+    if (path !== "" && !seen.includes(path)) seen.push(path);
+  }
+  return seen;
+}
+
+export {
+  INGEST_CLICK_ID_PARAMS,
+  SOURCE_FIELD_NAMES,
+  mappingRowProblem,
+  mentionOf,
+  templateMentions
+};
+//# sourceMappingURL=chunk-NKQWDEB7.js.map

package/dist/chunk-NKQWDEB7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../api/src/event-ingest/vocabulary.ts","../../api/src/event-sources/fields.ts","../../api/src/event-sources/template.ts"],"sourcesContent":["/**\n * The click ids a sender may hand over, named the way their own system stored\n * them.\n *\n * The wire uses the **URL parameter** spelling (`li_fat_id`) rather than the\n * analytics row's field spelling (`liFatId`), because a client's CRM captured\n * these off a landing URL and that is the name it wrote them down under.\n * {@link clickIdsFromWire} is the one place the two vocabularies meet.\n *\n * Mirrored from `CLICK_ID_FIELDS` in `../analytics/normalize.ts`, which is the\n * source of truth for which click ids the store has columns for.\n * `vocabulary.parity.test.ts` reads that file and fails if the two drift — a\n * missing entry here is an attribution a client sent and we dropped.\n */\n\nimport type { ClickIdFields } from \"../analytics/normalize\";\n\nexport const INGEST_CLICK_ID_PARAMS = [\n  \"gclid\",\n  \"wbraid\",\n  \"gbraid\",\n  \"dclid\",\n  \"fbclid\",\n  \"ttclid\",\n  \"twclid\",\n  \"li_fat_id\",\n  \"msclkid\",\n  \"rdt_cid\",\n  \"epik\",\n  \"sccid\",\n  \"oppref\",\n] as const;\nexport type IngestClickIdParam = (typeof INGEST_CLICK_ID_PARAMS)[number];\n\nconst FIELD_FOR_PARAM: Readonly<Record<IngestClickIdParam, keyof ClickIdFields>> = {\n  gclid: \"gclid\",\n  wbraid: \"wbraid\",\n  gbraid: \"gbraid\",\n  dclid: \"dclid\",\n  fbclid: \"fbclid\",\n  ttclid: \"ttclid\",\n  twclid: \"twclid\",\n  li_fat_id: \"liFatId\",\n  msclkid: \"msclkid\",\n  rdt_cid: \"rdtCid\",\n  epik: \"epik\",\n  sccid: \"sccid\",\n  oppref: \"oppref\",\n};\n\n/** The wire's click block as the analytics row builder names its fields. Empty values are dropped. */\nexport function clickIdsFromWire(click: Partial<Record<IngestClickIdParam, string | null>> | null | undefined): {\n  clickIds: ClickIdFields;\n  kinds: IngestClickIdParam[];\n} {\n  const clickIds: ClickIdFields = {};\n  const kinds: IngestClickIdParam[] = [];\n  for (const param of INGEST_CLICK_ID_PARAMS) {\n    const value = click?.[param];\n    if (typeof value !== \"string\" || value === \"\") continue;\n    clickIds[FIELD_FOR_PARAM[param]] = value;\n    kinds.push(param);\n  }\n  return { clickIds, kinds };\n}\n","/**\n * What a source can be read into: the fields of an event, named the way\n * `POST /v1/events` already names them.\n *\n * Assembled from the ingest vocabulary rather than spelled a fourth time. A\n * mapping is `SourceField → dotted path`, and the field half of that pair has\n * to be a name the wire already accepts, because the whole of what a source\n * does is build an `IngestEventInput` and hand it to the same door the\n * client's own server would have used. A field that existed only here would be\n * a field the event could not carry.\n */\n\nimport { MATCH_FIELDS, type MatchField } from \"../event-ingest/matching\";\nimport type { IngestClickIdParam } from \"../event-ingest/vocabulary\";\nimport { INGEST_CLICK_ID_PARAMS } from \"../event-ingest/vocabulary\";\n\n/** Where a field sits on the sheet: one row per group, in this order. */\nexport type SourceFieldGroup = \"event\" | \"person\" | \"money\" | \"click\";\n\nexport type SourceField =\n  | \"event_name\"\n  | \"event_time\"\n  | \"event_id\"\n  | \"email\"\n  | \"phone\"\n  | \"external_id\"\n  | MatchField\n  | \"value\"\n  | \"currency\"\n  | IngestClickIdParam;\n\nexport interface SourceFieldSpec {\n  field: SourceField;\n  /** The product word for it — what the sheet and the CLI show. */\n  label: string;\n  group: SourceFieldGroup;\n}\n\nconst MATCH_LABELS: Readonly<Record<MatchField, string>> = {\n  first_name: \"First name\",\n  last_name: \"Last name\",\n  date_of_birth: \"Date of birth\",\n  gender: \"Gender\",\n  city: \"City\",\n  region: \"Region\",\n  postal_code: \"Postcode\",\n  country: \"Country\",\n};\n\nconst CLICK_LABELS: Readonly<Record<IngestClickIdParam, string>> = {\n  gclid: \"Google click id\",\n  wbraid: \"Google click id (iOS, web to app)\",\n  gbraid: \"Google click id (iOS, app)\",\n  dclid: \"Google click id (Display & Video)\",\n  fbclid: \"Meta click id\",\n  ttclid: \"TikTok click id\",\n  twclid: \"X click id\",\n  li_fat_id: \"LinkedIn click id\",\n  msclkid: \"Microsoft click id\",\n  rdt_cid: \"Reddit click id\",\n  epik: \"Pinterest click id\",\n  sccid: \"Snapchat click id\",\n  oppref: \"ChatGPT Ads click id\",\n};\n\nexport const SOURCE_FIELDS: readonly SourceFieldSpec[] = [\n  { field: \"event_name\", label: \"What happened\", group: \"event\" },\n  { field: \"event_time\", label: \"When it happened\", group: \"event\" },\n  { field: \"event_id\", label: \"Its id\", group: \"event\" },\n  { field: \"email\", label: \"Email\", group: \"person\" },\n  { field: \"phone\", label: \"Phone\", group: \"person\" },\n  { field: \"external_id\", label: \"Your own id for the person\", group: \"person\" },\n  ...MATCH_FIELDS.map((field) => ({ field, label: MATCH_LABELS[field], group: \"person\" as const })),\n  { field: \"value\", label: \"Amount\", group: \"money\" },\n  { field: \"currency\", label: \"Currency\", group: \"money\" },\n  ...INGEST_CLICK_ID_PARAMS.map((field) => ({ field, label: CLICK_LABELS[field], group: \"click\" as const })),\n];\n\nexport const SOURCE_FIELD_NAMES: readonly SourceField[] = SOURCE_FIELDS.map((spec) => spec.field);\n\nconst FIELD_SET: ReadonlySet<string> = new Set(SOURCE_FIELD_NAMES);\n\nexport function isSourceField(value: string): value is SourceField {\n  return FIELD_SET.has(value);\n}\n\nexport const SOURCE_FIELD_GROUPS: readonly { group: SourceFieldGroup; label: string; detail: string }[] = [\n  { group: \"event\", label: \"The event\", detail: \"What it is called, when it happened, and its own id.\" },\n  {\n    group: \"person\",\n    label: \"Who it is about\",\n    detail: \"How the platforms find the person. Email or phone is the one that matters.\",\n  },\n  {\n    group: \"money\",\n    label: \"What it was worth\",\n    detail: \"The amount and its currency, for revenue and for the platforms.\",\n  },\n  {\n    group: \"click\",\n    label: \"The ad click that brought them\",\n    detail: \"When the source keeps the click id, the campaign gets the credit.\",\n  },\n];\n\n/**\n * A row that is not a field of the event but one of its own **properties** —\n * the flat `properties` object every event carries, which Measure → Events\n * breaks an event down by and which a send can forward to a platform as an\n * extra parameter (Meta's `custom_data`, a GA4 event parameter).\n *\n * Spelled `properties.<key>` in the mapping so the row shares the table with\n * the fields and the CLI's `--field` takes it unchanged, while an unknown bare\n * key is still refused: the namespace is what tells a deliberate extra\n * property from a typo that would otherwise silently map nothing.\n */\nexport const PROPERTY_ROW_PREFIX = \"properties.\";\n\n/** The longest a property's key may be. Keys are a shared dictionary in the store, so they are kept short and plain. */\nexport const PROPERTY_KEY_MAX = 64;\n\n/** Letters, digits, underscore, dash and dot — what a property key of `POST /v1/events` may be, and what a platform parameter name may be. */\nconst PROPERTY_KEY = /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/;\n\n/** Keys a source writes itself; a row naming one would be overwritten in silence. */\nexport const RESERVED_PROPERTY_KEYS: readonly string[] = [\"baker_source\", \"hubspot_property\", \"hubspot_value\"];\n\n/** Whether a mapping row names a property rather than a field. */\nexport function isPropertyRow(row: string): boolean {\n  return row.startsWith(PROPERTY_ROW_PREFIX);\n}\n\n/** The property's own key, for a `properties.<key>` row; null for anything else. */\nexport function propertyKeyOf(row: string): string | null {\n  return isPropertyRow(row) ? row.slice(PROPERTY_ROW_PREFIX.length) : null;\n}\n\n/** The mapping row for a property key. */\nexport function propertyRow(key: string): string {\n  return `${PROPERTY_ROW_PREFIX}${key}`;\n}\n\n/**\n * Why a property key cannot be used, in one sentence, or null when it can.\n * The same rule for a source's extra properties and for a send's parameters.\n */\nexport function propertyKeyProblem(key: string): string | null {\n  const trimmed = key.trim();\n  if (trimmed === \"\") return \"A property needs a name.\";\n  if (trimmed.length > PROPERTY_KEY_MAX) return `A property name is at most ${PROPERTY_KEY_MAX} characters.`;\n  if (!PROPERTY_KEY.test(trimmed)) {\n    return `\"${trimmed}\" is not a property name: letters, digits, underscore, dash and dot only, starting with a letter or digit.`;\n  }\n  if (RESERVED_PROPERTY_KEYS.includes(trimmed)) return `\"${trimmed}\" is written by Baker itself; pick another name.`;\n  return null;\n}\n\n/**\n * Whether a mapping row is one a source can hold: a field of the event, or a\n * well-named property. The reason when it is not.\n */\nexport function mappingRowProblem(row: string): string | null {\n  if (isSourceField(row)) return null;\n  const key = propertyKeyOf(row);\n  if (key === null) {\n    return `\"${row}\" is not a field an event can carry. A field is one of ${SOURCE_FIELD_NAMES.join(\", \")}; an extra property is spelled properties.<name>.`;\n  }\n  return propertyKeyProblem(key);\n}\n\n/** The property rows of a mapping, as `key → template`, in the order stored. */\nexport function propertyRows(mapping: Readonly<Record<string, string>>): { key: string; template: string }[] {\n  return Object.entries(mapping).flatMap(([row, template]) => {\n    const key = propertyKeyOf(row);\n    return key === null ? [] : [{ key, template }];\n  });\n}\n","/**\n * A mapping row is a template: literal text with `{{mentions}}` in it.\n *\n * ## Why a template and not a path\n *\n * A row used to hold one dotted path, and one path answers one question —\n * \"which field of the payload is the email\". It cannot answer the next three:\n * a currency the tool never sends but the company knows (`EUR`), a name split\n * over two fields (`{{firstname}} {{lastname}}`), or an amount a HubSpot\n * contact carries under a property nobody would guess. A template answers all\n * of them with one rule the Forms builder already teaches: type text, insert\n * a variable. The same spelling is what the CLI takes, so an agent and a\n * person write the same thing.\n *\n * ## What a mention points at\n *\n * Whatever the source can read. For an address it is a dotted path into the\n * payload (`contact.email`, `deal.contacts.0.email`); for a HubSpot read it\n * is a contact property's internal name (`hs_google_click_id`), plus `id` for\n * the contact's own id. The template does not know which — the lookup passed\n * to `renderTemplate` does.\n *\n * A mention names exactly one thing. There was a `{{phone|mobilephone}}`\n * spelling for \"the first that holds anything\"; it is gone, because it was a\n * rule the Forms builder's variables do not have, and a row that reads\n * differently from every other variable field in the product is a row nobody\n * can predict. A person who wants the mobile picks the mobile.\n */\n\nconst MENTION = /\\{\\{\\s*([^{}]+?)\\s*\\}\\}/g;\n\n/** The path a mention names, with the braces on. */\nexport function mentionOf(path: string): string {\n  return `{{${path}}}`;\n}\n\n/** Every path a template reads, in order, once each. */\nexport function templateMentions(template: string): string[] {\n  const seen: string[] = [];\n  for (const match of template.matchAll(MENTION)) {\n    const path = (match[1] ?? \"\").trim();\n    if (path !== \"\" && !seen.includes(path)) seen.push(path);\n  }\n  return seen;\n}\n\n/**\n * The template with every mention replaced by what it points at, trimmed —\n * or nothing, when what is left is empty. An empty mention reads as empty\n * text rather than as its own spelling, so a template made only of mentions\n * the payload did not fill is \"not sent\", not the literal `{{phone}}`.\n */\nexport function renderTemplate(template: string, lookup: (path: string) => string | undefined): string | undefined {\n  const rendered = template.replace(MENTION, (_whole, path: string) => lookup(path.trim()) ?? \"\").trim();\n  return rendered === \"\" ? undefined : rendered;\n}\n\n/** The one path a template is, when it is exactly one mention and nothing else. */\nexport function isBareMention(template: string): string | null {\n  const match = /^\\{\\{\\s*([^{}]+?)\\s*\\}\\}$/.exec(template.trim());\n  return match === null ? null : (match[1] ?? null);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-NWF2LRKO.js

@@ -0,0 +1,188 @@
+import {
+  analyticsErrorEnvelope
+} from "./chunk-WLESMH4J.js";
+import {
+  PEOPLE_SEARCH_MAX_TERMS,
+  parsePeopleQuery,
+  peopleLookupRequestSchema
+} from "./chunk-JOE42ZW6.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/analytics/lookup.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+function peopleArgs(args2) {
+  const parts = peopleParts(args2);
+  if (parts.length === 0) return {};
+  const people = parsePeopleQuery(parts).terms.map((term) => term.input);
+  return people.length === 0 ? {} : { people };
+}
+function peopleParts(args2) {
+  return [...args2.person ? [String(args2.person)] : [], ...args2["people-file"] ? [readPeopleFile(args2)] : []];
+}
+function readPeopleFile(args2) {
+  try {
+    return readFileSync(String(args2["people-file"]), "utf8");
+  } catch {
+    return "";
+  }
+}
+function unreadablePeopleFile(args2) {
+  if (!args2["people-file"]) return void 0;
+  const path = String(args2["people-file"]);
+  try {
+    readFileSync(path, "utf8");
+    return void 0;
+  } catch {
+    return `Couldn't read --people-file ${path}. Check the path, or pass the people inline with --person.`;
+  }
+}
+function peopleLimitError(args2) {
+  const unreadable = unreadablePeopleFile(args2);
+  if (unreadable !== void 0) return unreadable;
+  const { terms, dropped } = parsePeopleQuery(peopleParts(args2));
+  if (dropped === 0) return void 0;
+  return `${terms.length + dropped} people named; one search takes up to ${PEOPLE_SEARCH_MAX_TERMS}. Split the list and run each part.`;
+}
+function compactRow(row) {
+  const clicks = [...row.googleClick ? ["google"] : [], ...row.metaClick ? ["meta"] : []];
+  const candidates = {
+    input: row.input,
+    readAs: row.kind,
+    found: row.found,
+    problem: row.problem,
+    contacts: row.contacts,
+    events: row.events,
+    firstSeen: row.firstSeen,
+    lastSeen: row.lastSeen,
+    pageViews: row.pageViews,
+    landings: row.landings,
+    visits: row.visits,
+    formSubmits: row.formSubmits,
+    firstSource: row.firstSource,
+    systemEvents: row.systemEvents,
+    pageEvents: row.pageEvents,
+    uploads: row.uploads,
+    uploadedTo: row.uploadedTo,
+    clicks,
+    knownBy: row.knownBy
+  };
+  return Object.fromEntries(
+    Object.entries(candidates).filter(
+      ([key, value]) => key === "found" || !(value === 0 || value === "" || Array.isArray(value) && value.length === 0)
+    )
+  );
+}
+function lookupHints(data) {
+  const hints = [];
+  if (data.dropped > 0) {
+    hints.push(
+      `${data.dropped} lines past the limit of ${PEOPLE_SEARCH_MAX_TERMS} were not looked up. Run the rest separately.`
+    );
+  }
+  const unseen = data.people.filter((row) => !row.found && row.problem === "");
+  if (unseen.length > 0) {
+    hints.push(
+      `Not seen by Baker: ${unseen.map((row) => row.input).join(", ")}. Baker knows a person by what its pages, Forms and connected systems recorded \u2014 a lead that came in through a form or site Baker does not measure, or a source not connected, is not here.`
+    );
+  }
+  for (const row of data.people.filter((person) => person.problem !== "")) {
+    hints.push(`${row.input}: ${row.problem}`);
+  }
+  const found = data.people.filter((row) => row.found);
+  const neverVisited = found.filter((row) => row.pageViews === 0);
+  if (neverVisited.length > 0) {
+    hints.push(
+      `${neverVisited.length} of ${found.length} found never visited a page Baker publishes: Baker knows them only from what their systems reported, so no landing can be credited with them.`
+    );
+  }
+  if (found.length > 0) {
+    hints.push(
+      `\`baker analytics feed --person '${found[0]?.input}' --days 90\` lists everything one of them did, in order \u2014 add more, comma-separated, to follow several.`
+    );
+  }
+  return hints;
+}
+function lookupReport(data, full = false) {
+  const found = data.people.filter((row) => row.found);
+  return {
+    summary: {
+      searched: data.people.length,
+      found: found.length,
+      notFound: data.people.length - found.length,
+      visitedABakerPage: found.filter((row) => row.pageViews > 0).length
+    },
+    people: full ? data.people : data.people.map(compactRow),
+    hints: lookupHints(data)
+  };
+}
+var NO_PEOPLE = "Name at least one person: --person 'ana@empresa.com, deal:40001234567' or --people-file leads.txt.";
+var args = {
+  person: {
+    type: "string",
+    description: "The people, comma-separated: an email, a phone (+34\u2026), a HubSpot contact id, deal:<HubSpot deal id>, a gclid/fbclid, a browser id. Prefix to be exact: email:, phone:, hubspot:, deal:, gclid:, fbclid:, browser:",
+    required: false
+  },
+  "people-file": {
+    type: "string",
+    description: "A file with one person per line \u2014 a column pasted from a CRM export",
+    required: false
+  },
+  full: {
+    type: "boolean",
+    description: "Every field of every line, zeros included",
+    required: false
+  }
+};
+registerSchema({
+  command: "analytics.lookup",
+  description: "What Baker saw of each person in a list, by email, phone, CRM id, deal or click id",
+  args
+});
+var lookupCommand = defineCommand({
+  meta: {
+    name: "lookup",
+    description: `What Baker saw of each person in a list \u2014 all time, one line each \u2014 by whatever the client holds about them. The reconciliation question: "HubSpot says 26 leads yesterday, which of them does Baker have, and where did they come from".
+
+Start here:
+  baker analytics lookup --person 'ana@empresa.com, +34600111222, 90001234567'
+  baker analytics lookup --person 'deal:40001234567, deal:40001234568'   \u2014 HubSpot deal ids, looked up through the deal's contacts
+  baker analytics lookup --people-file leads.txt                           \u2014 one per line, up to ${PEOPLE_SEARCH_MAX_TERMS}
+
+Each line says whether Baker has them, when it first and last saw them, the pages and Forms they touched, what their systems reported (systemEvents: CRM stages, orders), what Baker uploaded for them to ad platforms, which ad click they carried, and every kind of key they are linked by. A bare number is read as a HubSpot contact id or a phone; prefix it to be exact. Emails and phones are hashed by Baker \u2014 say them to the client as they gave them, never as a hash. Follow one with \`baker analytics feed --person <same value>\`.`
+  },
+  args,
+  run: async ({ args: raw }) => {
+    const { people } = peopleArgs(raw);
+    const parsed = peopleLookupRequestSchema.safeParse({ people: people ?? [] });
+    const invalid = peopleLimitError(raw) ?? (parsed.success ? void 0 : NO_PEOPLE);
+    if (invalid !== void 0 || !parsed.success) {
+      writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: invalid ?? NO_PEOPLE } });
+      process.exit(1);
+    }
+    try {
+      const response = await apiPost("/api/analytics/people", parsed.data);
+      const { hints, ...data } = lookupReport(response.data, raw.full === true);
+      writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+    } catch (error) {
+      writeJsonEnvelope({ ok: false, error: analyticsErrorEnvelope(error) });
+      process.exit(1);
+    }
+  }
+});
+
+export {
+  peopleArgs,
+  peopleLimitError,
+  lookupReport,
+  lookupCommand
+};
+//# sourceMappingURL=chunk-NWF2LRKO.js.map