@koda-sl/baker-cli 0.453.0 → 0.454.0-dev.67ad219ab

package/dist/chunk-3J62OINP.js

@@ -0,0 +1,310 @@
+import {
+  mappingRowProblem,
+  mentionOf
+} from "./chunk-EDLZGTGN.js";
+import {
+  CONDITION_LOGICS,
+  HUBSPOT_DEAL_CONTACTS,
+  HUBSPOT_OBJECTS,
+  HUBSPOT_PROPERTY_KINDS,
+  REJECTION_MESSAGES,
+  TRIGGER_CONDITIONS_MAX,
+  onlyCondition,
+  triggerProblem,
+  validateEventName
+} from "./chunk-IDYAVGCS.js";
+
+// ../api/src/event-sources/hubspot.ts
+var HUBSPOT_CONTACT_ID_VARIABLE = "id";
+var HUBSPOT_CONTACT_PREFIX = "contact.";
+function contactPath(property) {
+  return `${HUBSPOT_CONTACT_PREFIX}${property}`;
+}
+var HUBSPOT_DEFAULT_PROPERTIES = {
+  email: "email",
+  phone: "phone",
+  external_id: HUBSPOT_CONTACT_ID_VARIABLE,
+  first_name: "firstname",
+  last_name: "lastname",
+  city: "city",
+  postal_code: "zip",
+  country: "country",
+  gclid: "hs_google_click_id",
+  fbclid: "hs_facebook_click_id"
+};
+var throughContact = Object.fromEntries(
+  Object.entries(HUBSPOT_DEFAULT_PROPERTIES).map(([field, property]) => [field, contactPath(property)])
+);
+var HUBSPOT_DEAL_DEFAULT_PROPERTIES = {
+  ...throughContact,
+  value: "amount",
+  currency: "deal_currency_code"
+};
+var HUBSPOT_LEAD_DEFAULT_PROPERTIES = throughContact;
+var DEFAULTS = {
+  contact: HUBSPOT_DEFAULT_PROPERTIES,
+  deal: HUBSPOT_DEAL_DEFAULT_PROPERTIES,
+  lead: HUBSPOT_LEAD_DEFAULT_PROPERTIES
+};
+function hubspotDefaultMapping(sourceName, object = "contact") {
+  const mapping = { event_name: sourceName };
+  for (const [field, property] of Object.entries(DEFAULTS[object])) {
+    mapping[field] = mentionOf(property);
+  }
+  return mapping;
+}
+
+// ../api/src/event-sources/wire.ts
+import { z } from "zod";
+var SOURCE_KINDS = ["webhook", "hubspot"];
+var SOURCE_STATUSES = ["learning", "counting", "paused"];
+var SOURCE_NAME_MAX = 80;
+var sourceNameSchema = z.string().trim().min(1).max(SOURCE_NAME_MAX).refine((name) => validateEventName(name) === null, REJECTION_MESSAGES.invalid_name);
+var sourceIdSchema = z.string().min(1);
+var sourceMappingSchema = z.record(z.string(), z.string().min(1)).superRefine((mapping, ctx) => {
+  for (const row of Object.keys(mapping)) {
+    const problem = mappingRowProblem(row);
+    if (problem !== null) ctx.addIssue({ code: "custom", message: problem, path: [row] });
+  }
+});
+var currencyCodeSchema = z.string().trim().toUpperCase().regex(/^[A-Z]{3}$/, "A currency is a three-letter code, like EUR or USD.");
+var hubspotObjectSchema = z.enum(HUBSPOT_OBJECTS);
+var hubspotDealContactsSchema = z.enum(HUBSPOT_DEAL_CONTACTS);
+var hubspotConditionInputSchema = z.strictObject({
+  property: z.string().trim().min(1),
+  /** One of the property's kind's operators (`baker hubspot contacts properties` lists them); `is` when unsaid. */
+  operator: z.string().trim().min(1).default("is"),
+  /** As HubSpot spells them: an option's internal value, a number, a `YYYY-MM-DD`, `true`/`false`. None for an empty check, two for a between, several for a list. */
+  values: z.array(z.string().trim().min(1)).max(50).default([])
+});
+var conditionLogicSchema = z.enum(CONDITION_LOGICS);
+var conditionGroupInputSchema = z.strictObject({
+  logic: conditionLogicSchema,
+  conditions: z.array(hubspotConditionInputSchema).min(1).max(TRIGGER_CONDITIONS_MAX)
+});
+var combinedInputSchema = z.strictObject({
+  /** How the rows combine: `And` (every one) or `Or` (any one) — a Form's filter's "Match AND / OR". */
+  logic: conditionLogicSchema.default("And"),
+  /** Conditions, and groups of conditions with their own logic, one level deep. */
+  conditions: z.array(z.union([hubspotConditionInputSchema, conditionGroupInputSchema])).min(1).max(TRIGGER_CONDITIONS_MAX)
+}).superRefine((trigger, context) => {
+  const problem = triggerProblem(trigger);
+  if (problem !== null) context.addIssue({ code: "custom", message: problem });
+});
+var hubspotTriggerInputSchema = z.union([combinedInputSchema, hubspotConditionInputSchema]).transform((input) => "conditions" in input ? input : onlyCondition(input));
+var hubspotConditionSchema = hubspotConditionInputSchema.extend({
+  propertyLabel: z.string(),
+  kind: z.enum(HUBSPOT_PROPERTY_KINDS),
+  /** A select that holds several values at once (`a;b`); decides what HubSpot may filter on. */
+  multiple: z.boolean().optional(),
+  valueLabels: z.array(z.string())
+});
+var hubspotTriggerFields = {
+  logic: conditionLogicSchema,
+  conditions: z.array(
+    z.union([
+      hubspotConditionSchema,
+      z.strictObject({ logic: conditionLogicSchema, conditions: z.array(hubspotConditionSchema) })
+    ])
+  )
+};
+var hubspotWatchSchema = z.strictObject({
+  ...hubspotTriggerFields,
+  object: hubspotObjectSchema,
+  contacts: hubspotDealContactsSchema.optional()
+});
+var sampleRecordSchema = z.strictObject({ id: z.string(), properties: z.record(z.string(), z.string()) });
+var hubspotPreviewRequestSchema = z.strictObject({
+  object: hubspotObjectSchema.default("contact"),
+  trigger: hubspotTriggerInputSchema,
+  /** Property names to read off the sample; `id` is always there. On a deal or a lead, `contact.<name>` reads its first contact. */
+  properties: z.array(z.string().trim().min(1)).max(60).optional(),
+  /** The record to draw the preview from — an id, or text to search (an email or a name for a contact, a deal's or a lead's name). The one most recently at the trigger when unsaid. */
+  contact: z.string().trim().min(1).max(200).optional()
+});
+var hubspotPreviewSchema = z.strictObject({
+  /** Records satisfying the trigger today — the ones that will NOT be counted. */
+  total: z.number(),
+  /** False when the trigger has more combinations than HubSpot's search takes, so `total` is only near. */
+  exact: z.boolean().optional(),
+  /**
+   * The sample record the trigger is on, with the properties asked for and
+   * the contacts behind it, first first; none when nothing fits.
+   *
+   * One field rather than one per object: a contact source's record *is* the
+   * person and its `contacts` is empty, while a deal's and a lead's carry the
+   * people the event is about. Three parallel nullable fields, exactly one of
+   * them ever set, would say the same thing and let a caller read the wrong one.
+   */
+  record: sampleRecordSchema.extend({ contacts: z.array(sampleRecordSchema) }).nullable()
+});
+var sourcesRequestSchema = z.strictObject({
+  /** The company's own server door: made once, `counting` from the start, the same address for ever after. */
+  server: z.strictObject({}).optional(),
+  create: z.strictObject({ name: sourceNameSchema }).optional(),
+  /** A HubSpot event: read every five minutes, counting from now. The labels are looked up server-side. */
+  createHubspot: z.strictObject({
+    name: sourceNameSchema.optional(),
+    /** A contact, a deal or a lead. A deal's and a lead's event is about its contact, read through `contact.<property>` rows. */
+    object: hubspotObjectSchema.default("contact"),
+    trigger: hubspotTriggerInputSchema,
+    /** On a deal: the deal's first contact (the default), or every contact on it, each its own event. */
+    contacts: hubspotDealContactsSchema.optional(),
+    /** Rows to read off the record, over the defaults; the same table `map` writes. */
+    mapping: sourceMappingSchema.optional(),
+    /** A number property on the record to read as the amount; needs `currency` beside it. Sugar over the mapping's `value` and `currency` rows. */
+    amountProperty: z.string().trim().min(1).optional(),
+    currency: currencyCodeSchema.optional()
+  }).optional(),
+  /** Change what a HubSpot event watches. It counts from now on under the new trigger; the rows stay. The object cannot change: the rows read it. */
+  setTrigger: z.strictObject({
+    sourceId: sourceIdSchema,
+    trigger: hubspotTriggerInputSchema,
+    contacts: hubspotDealContactsSchema.optional()
+  }).optional(),
+  /** Ask HubSpot what a trigger would count today, and read one real record, without making anything. */
+  preview: hubspotPreviewRequestSchema.optional(),
+  /** Change where a HubSpot-read source takes its amount from; no `amountProperty` clears it. Sugar over `map`. */
+  setAmount: z.strictObject({
+    sourceId: sourceIdSchema,
+    amountProperty: z.string().trim().min(1).optional(),
+    currency: currencyCodeSchema.optional()
+  }).optional(),
+  /**
+   * Count a HubSpot event's history: every moment its trigger came to hold
+   * since `since`, read out of HubSpot's own property history.
+   *
+   * Not the thing a source deliberately refuses to do. A source never
+   * backfills the **present state** — somebody who already satisfies a
+   * condition is not an event today — and this reports only moments HubSpot
+   * has a timestamp for, so nothing is invented. Dry unless `write`.
+   */
+  backfill: z.strictObject({
+    sourceId: sourceIdSchema,
+    /** ISO instant, or Unix milliseconds. Bounded by the 400 days the store keeps. */
+    since: z.union([z.string().trim().min(1), z.number()]),
+    /**
+     * Where a capped run carries on from: only records last changed at or
+     * before this instant are read.
+     *
+     * The **read** is what it bounds, never the history. Records are chosen
+     * most-recently-changed first, so a run that reaches its cap has covered
+     * the newest of them and the rest are the ones nearest `since` — which
+     * no shorter window can reach, because shortening one only drops
+     * candidates from the old end and hands back the same newest records
+     * again. `reachedBack` is the value to pass here, and the moments each
+     * record is then judged on are still the whole of `since` to now.
+     */
+    before: z.union([z.string().trim().min(1), z.number()]).optional(),
+    /** Without it, nothing is counted and the answer says what would be. */
+    write: z.boolean().optional()
+  }).optional(),
+  map: z.strictObject({ sourceId: sourceIdSchema, mapping: sourceMappingSchema }).optional(),
+  pause: z.strictObject({ sourceId: sourceIdSchema }).optional(),
+  resume: z.strictObject({ sourceId: sourceIdSchema }).optional(),
+  remove: z.strictObject({ sourceId: sourceIdSchema }).optional()
+});
+var sourceRefusalSchema = z.strictObject({
+  at: z.number(),
+  count: z.number(),
+  code: z.string(),
+  reason: z.string()
+});
+var detectedFieldSchema = z.strictObject({
+  path: z.string(),
+  confidence: z.enum(["key", "value"])
+});
+var HUBSPOT_LISTENING_STATES = ["listening", "not_configured", "failed"];
+var sourceViewSchema = z.strictObject({
+  id: z.string(),
+  kind: z.enum(SOURCE_KINDS),
+  name: z.string(),
+  status: z.enum(SOURCE_STATUSES),
+  /** The address a tool posts to. A HubSpot source has none: Baker calls HubSpot. */
+  url: z.string().optional(),
+  /** What a HubSpot source watches, and on which object. */
+  hubspot: hubspotWatchSchema.optional(),
+  /** A HubSpot source counts changes from here on; one HubSpot reports from before it is dropped. Moves when the trigger changes. */
+  countingSince: z.number().optional(),
+  /**
+   * Whether HubSpot is keeping this source's changes for Baker, as last
+   * checked: `listening` when the app's journal subscription on the account
+   * names the property; `not_configured` when the app has not been told yet
+   * (or cannot be, with no credentials); `failed` when HubSpot refused the
+   * subscription. `detail` says what to do.
+   */
+  listening: z.strictObject({ state: z.enum(HUBSPOT_LISTENING_STATES), detail: z.string().optional() }).optional(),
+  /** Why the last delivery could not be counted, in product words; absent when the last one was. */
+  lastError: z.string().optional(),
+  lastArrivalAt: z.number().optional(),
+  /**
+   * What its last delivery **refused, event by event** — which `lastError` is
+   * not and `lastArrivalAt` cannot be. A source refusing everything it
+   * receives has no arrival and no read failure, so without this it reads as
+   * one nobody has sent anything to. `refusalWords` turns it into the
+   * sentence a person is shown. Cleared by the next delivery that counts.
+   */
+  lastRefusal: sourceRefusalSchema.optional(),
+  /** The first send, masked, while learning. Kept once confirmed. */
+  sample: z.strictObject({ receivedAt: z.number(), body: z.string() }).optional(),
+  /** Field → template; empty means the guess (an address) or the defaults (a HubSpot read). */
+  mapping: z.record(z.string(), z.string()),
+  /** The guess over the sample, for the sheet to prefill and the CLI to suggest. */
+  detected: z.record(z.string(), detectedFieldSchema).optional(),
+  /** Every path the sample's first item holds, with its masked value — what the picker offers. */
+  paths: z.array(z.strictObject({ path: z.string(), value: z.string() })).optional(),
+  /** `baker` when the sample already parses as the `POST /v1/events` contract and needs no mapping. */
+  format: z.enum(["baker", "foreign"]).optional()
+});
+var stagedSourceOpSchema = z.strictObject({
+  kind: z.enum(["create", "setTrigger", "map", "status", "remove"]),
+  ref: z.string(),
+  name: z.string(),
+  summary: z.string(),
+  /** On a create: what the source will watch and read. */
+  hubspot: hubspotWatchSchema.optional(),
+  mapping: z.record(z.string(), z.string()).optional(),
+  status: z.enum(["paused", "counting"]).optional()
+});
+var backfillResultSchema = z.strictObject({
+  sourceId: z.string(),
+  name: z.string(),
+  since: z.number(),
+  /** Records whose history was read. */
+  examined: z.number(),
+  /** Moments the trigger came to hold, across them. */
+  entries: z.number(),
+  /** Of those, already counted — the journal got there first, or a previous run did. */
+  alreadyCounted: z.number(),
+  /** What a `write` run would hand over, or did. */
+  pending: z.number(),
+  /** Whether the read stopped at its cap; {@link BackfillResult.reachedBack} is where to carry on from. */
+  capped: z.boolean(),
+  /**
+   * How far back the read got: the instant the oldest record it examined was
+   * last changed. Only on a capped run, and it is the next run's `before`.
+   */
+  reachedBack: z.number().optional(),
+  counted: z.number().optional(),
+  refused: z.number().optional(),
+  refusedReason: z.string().optional()
+});
+var sourcesResponseSchema = z.strictObject({
+  ok: z.literal(true),
+  data: z.strictObject({
+    sources: z.array(sourceViewSchema),
+    /** Only when the request carried `preview`. */
+    preview: hubspotPreviewSchema.optional(),
+    /** Only when the request carried `backfill`. */
+    backfill: backfillResultSchema.optional(),
+    /** What this chat has staged, when one is attached: applied at Publish, dropped with a discard. */
+    staged: z.array(stagedSourceOpSchema).optional()
+  }),
+  hints: z.array(z.string()).optional()
+});
+
+export {
+  hubspotDefaultMapping,
+  hubspotTriggerInputSchema
+};
+//# sourceMappingURL=chunk-3J62OINP.js.map

package/dist/chunk-3REUG4QF.js

@@ -0,0 +1,94 @@
+import {
+  ApiError
+} from "./chunk-5BQCBI2G.js";
+import {
+  writeJson
+} from "./chunk-5WW456MW.js";
+
+// src/commands/landing/inspiration/shared.ts
+var INSPIRATION_HINTS = {
+  adapt: "Reference only. Re-express this in the client's BRAND.md palette, type and imagery register. Reusing a headline, subhead or CTA verbatim is a Tier 0 message-match failure (references/gotchas.md).",
+  structureNotCopy: "Take the structural decision, not the furniture: what the eye hits first, the grid ratio, what was deliberately left out. Your copy must come from the client's own offer."
+};
+function favoritesScopeHints(health, resultCount) {
+  if (!health) return [];
+  const hints = [];
+  if (health.savedPages === 0) {
+    hints.push(
+      "This company hasn't saved any reference pages yet, so there is no taste profile to search \u2014 an empty result here says nothing about the library. Search the whole shared library with --scope all, or save a page the client admires with `baker landing inspiration add <url>`."
+    );
+    return hints;
+  }
+  if (health.failedPages > 0) {
+    const retryable = health.failedExamples.filter((example) => example.retryable).map((example) => example.url);
+    const permanent = health.failedExamples.filter((example) => !example.retryable).map((example) => example.url);
+    hints.push(
+      `${health.failedPages} of this company's ${health.savedPages} saved pages could not be read, so they hold no sections \u2014 only ${health.usablePages} are usable, which is why this result is thin. Search the whole library with --scope all.`
+    );
+    if (retryable.length > 0) {
+      hints.push(
+        `Worth another go: ${retryable.join(", ")} \u2014 run \`baker landing inspiration add <url>\` on one of them to study it again.`
+      );
+    }
+    if (permanent.length > 0) {
+      hints.push(`Not worth retrying \u2014 these sites refuse automated readers: ${permanent.join(", ")}.`);
+    }
+  }
+  if (health.studyingPages > 0) {
+    hints.push(
+      `${health.studyingPages} saved ${health.studyingPages === 1 ? "page is" : "pages are"} still being studied and will be searchable in a few minutes. Carry on; do not wait on them.`
+    );
+  }
+  if (resultCount === 0 && health.failedPages === 0 && health.studyingPages === 0) {
+    hints.push(
+      `Nothing in this company's ${health.usablePages} readable saved pages matches. The saved set is healthy, so this is the query, not the library \u2014 loosen the filters or search everything with --scope all.`
+    );
+  }
+  return hints;
+}
+function fidelityHint(fidelity) {
+  if (fidelity == null) return null;
+  if (fidelity >= 0.9) return null;
+  if (fidelity >= 0.75) {
+    return `Reproduction fidelity ${fidelity.toFixed(2)} \u2014 the markup is close but not exact. Trust the screenshot over the code.`;
+  }
+  return `Reproduction fidelity ${fidelity.toFixed(2)} \u2014 this section is scroll- or JS-driven and the extracted markup does NOT render like the original. Use the screenshot and the notes; treat the code as a hint only.`;
+}
+var STALE_COPY_AFTER_MS = 30 * 24 * 60 * 60 * 1e3;
+function staleCopyHint(studiedAt, filedUrl, now = Date.now()) {
+  if (!studiedAt || now - studiedAt < STALE_COPY_AFTER_MS) return null;
+  const date = new Date(studiedAt).toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
+  return `This copy of the page was read on ${date}. If the user says the live page looks different, run: baker landing inspiration add ${filedUrl} --refresh`;
+}
+function reportError(error) {
+  if (error instanceof ApiError) {
+    writeJson({ ok: false, error: { code: error.code, message: error.message } });
+  } else {
+    writeJson({
+      ok: false,
+      error: { code: "UNKNOWN", message: error instanceof Error ? error.message : String(error) }
+    });
+  }
+  process.exit(1);
+}
+function splitList(value) {
+  if (!value) return void 0;
+  const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function parseNumber(value) {
+  if (value === void 0 || value === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+
+export {
+  INSPIRATION_HINTS,
+  favoritesScopeHints,
+  fidelityHint,
+  staleCopyHint,
+  reportError,
+  splitList,
+  parseNumber
+};
+//# sourceMappingURL=chunk-3REUG4QF.js.map