@koda-sl/baker-cli 0.534.0-dev.911a80433 → 0.535.0

package/dist/accounts-IW62WBX5.js

@@ -1,701 +0,0 @@
-import {
-  ACCOUNTS_ENGAGEMENT_MAX_LIMIT,
-  ACCOUNTS_NO_SETTINGS_MESSAGE,
-  INFLUENCE_MODEL_KINDS,
-  accountDealStatus,
-  accountsCampaignsRequestSchema,
-  accountsCompanyRequestSchema,
-  accountsEngagementRequestSchema,
-  accountsInfluencedRequestSchema,
-  influenceParams,
-  warmAccounts
-} from "./chunk-RIA5RXPL.js";
-import {
-  readTargetsFile
-} from "./chunk-MTV2RSGY.js";
-import "./chunk-45EERHDB.js";
-import "./chunk-GRQ2AXDX.js";
-import {
-  TABLE_OUTPUT_FORMATS,
-  outputFormatRefusal,
-  toCsvRow,
-  writeAdsOutput
-} from "./chunk-LV7EU6HM.js";
-import {
-  failApi
-} from "./chunk-7MY3QHGA.js";
-import "./chunk-DYOUJERF.js";
-import "./chunk-QV6AST5T.js";
-import "./chunk-WCU362Z6.js";
-import "./chunk-GIWHHCD6.js";
-import "./chunk-SOPVIIUW.js";
-import "./chunk-G4FG5EQO.js";
-import "./chunk-NSBNIPIW.js";
-import "./chunk-MUS2UTWU.js";
-import {
-  ApiError,
-  apiPost
-} from "./chunk-CIW3Q7B2.js";
-import "./chunk-O7AMKMII.js";
-import "./chunk-VPF5A7CM.js";
-import {
-  registerSchema,
-  writeJson
-} from "./chunk-HZPTQRX6.js";
-import "./chunk-YQSBHWOI.js";
-
-// src/commands/accounts/index.ts
-import { readFileSync } from "fs";
-import { defineCommand } from "citty";
-import { z } from "zod";
-
-// src/commands/accounts/report.ts
-function accountsRefusal(code, message) {
-  if (code === "CONFLICT" && message.includes(ACCOUNTS_NO_SETTINGS_MESSAGE)) {
-    return {
-      code: "ACCOUNTS_NOT_SET_UP",
-      fix: {
-        action: "ask_user",
-        explanation: "The user sets up where the deals are in Measure \u2192 Accounts first: HubSpot (then its pipelines and won/lost stages), or Another CRM, whose deals they send by spreadsheet or from their system (`baker accounts crm status`). Only the user can say which stages mean won and lost; do not guess them. Until then `baker accounts engagement` and `baker accounts warm` still work \u2014 they need no deals."
-      }
-    };
-  }
-  return null;
-}
-var FLAG_OF_FIELD = {
-  lastMonths: "--last-months",
-  start: "--start",
-  end: "--end",
-  campaignId: "--campaign-id",
-  limit: "--limit",
-  basis: "--basis",
-  model: "--model",
-  threshold: "--threshold",
-  orgId: "company",
-  domain: "company",
-  targets: "--targets"
-};
-function invalidArgsMessage(issues) {
-  return issues.map((issue) => {
-    const field = issue.path.map(String).join(".");
-    return `${FLAG_OF_FIELD[field] ?? (field || "args")}: ${issue.message}`;
-  }).join("; ");
-}
-function money(value) {
-  const parts = Object.entries(value).map(
-    ([currency, amount]) => `${Math.round(amount).toLocaleString("en")} ${currency}`
-  );
-  return parts.length > 0 ? parts.join(" + ") : "no amount";
-}
-function influencedHints(data) {
-  const hints = [];
-  const { summary } = data;
-  if (summary.lowConfidenceDeals > 0) {
-    const deals = summary.lowConfidenceDeals === 1 ? "deal" : "deals";
-    const look = summary.lowConfidenceDeals === 1 ? "looks" : "look";
-    hints.push(
-      `${summary.lowConfidenceDeals} more ${deals} (${money(summary.lowConfidenceValue)}) ${look} influenced through a company match that is only a guess (a subdomain or a name). They are not counted in the numbers until someone confirms the match in Measure \u2192 Accounts; they are listed under lowConfidence.`
-    );
-  }
-  const valued = Object.keys(summary.influencedValue).length > 0;
-  const spent = Object.values(summary.spend).some((amount) => amount > 0);
-  if (summary.valuePerSpend === null && valued && spent) {
-    hints.push(
-      `valuePerSpend is null because the influenced value (${money(summary.influencedValue)}) and the LinkedIn spend (${money(summary.spend)}) are not in one single currency \u2014 amounts in different currencies are never converted or added. Report them side by side.`
-    );
-  }
-  return hints;
-}
-function influencedTableRows(data, full) {
-  return full ? data.deals : [...data.deals, ...data.lowConfidence];
-}
-function engagementHints(data, request) {
-  if (data.companies.length === 0) {
-    return [
-      `No company the LinkedIn ads reached shows up for ${data.window.start} to ${data.window.end}. The nightly sync may not have run since the campaigns started delivering, or LinkedIn left the companies out (fewer than 3 events in a month). Try a longer period (--last-months 12), or read the ad account live with \`baker ads linkedin companies\`.`
-    ];
-  }
-  const page = data.pageInfo;
-  if (page?.hasMore) {
-    const first = (page.page - 1) * page.pageSize + 1;
-    const last = first + data.companies.length - 1;
-    return [
-      `Companies ${first}-${last} of ${page.total.toLocaleString("en")} shown. Read the next ones with --page ${page.page + 1} --limit ${page.pageSize}.`
-    ];
-  }
-  return data.truncated ? [`More companies were reached than --limit ${request.limit}; raise it to see the tail.`] : [];
-}
-var ENGAGEMENT_TABLE_FIELDS = [
-  "orgId",
-  "name",
-  "domain",
-  "impressions",
-  "clicks",
-  "engagements",
-  "videoViews",
-  "costLocal",
-  "currency",
-  "monthsActive",
-  "lastMonth",
-  "previousImpressions",
-  "previousClicks",
-  "previousEngagements",
-  "flag",
-  "crmCompanyId",
-  "matchConfidence",
-  "dealStatus",
-  "hasOpenDeal",
-  "hasWonDeal",
-  "hasLostDeal",
-  "lastLostAt",
-  "websitePeople",
-  "websiteLeads",
-  "websiteVisits",
-  "websitePagesRead",
-  "websiteLastVisit"
-];
-function engagementTableRows(rows) {
-  return withDealStatus(rows).map(({ previous, website, visitorCompany, ...row }) => ({
-    ...row,
-    previousImpressions: previous.impressions,
-    previousClicks: previous.clicks,
-    previousEngagements: previous.engagements,
-    websitePeople: website?.people ?? 0,
-    websiteLeads: website?.leads ?? 0,
-    websiteVisits: visitorCompany?.visits ?? 0,
-    websitePagesRead: visitorCompany?.pages ?? 0,
-    websiteLastVisit: visitorCompany?.lastSeen ?? null
-  }));
-}
-var MODEL_OF_METRIC = {
-  engagements: "engagement",
-  impressions: "awareness",
-  clicks: "intent"
-};
-function warmMinimum(rule, override) {
-  const saved = { model: { kind: rule ? MODEL_OF_METRIC[rule.metric] : "engagement", threshold: rule?.threshold } };
-  const read = influenceParams(saved, { model: override.model, threshold: override.threshold });
-  const value = override.min ?? read.threshold;
-  return value > 0 ? { metric: read.metric, value } : void 0;
-}
-function warmHints(read, warm, minimum) {
-  const hints = [];
-  if (read.truncated) {
-    hints.push(
-      `The ads reached more companies than one read returns (${read.companies.length.toLocaleString("en")}, the most engaged first), so warm companies with little engagement may be missing. Read a shorter period with --last-months 1 to see them.`
-    );
-  }
-  if (warm.length === 0 && read.companies.length > 0 && minimum !== void 0) {
-    hints.push(
-      `No company both warmed up and reached ${minimum.value}+ ${minimum.metric} in the period. Try a longer period with --last-months, or a lower bar with --min (--min 0 drops it).`
-    );
-  }
-  if (warm.some((row) => row.name === "")) {
-    hints.push("Some companies have no name yet \u2014 the nightly sync looks them up; the organizationUrn still matches.");
-  }
-  if (warm.length > 0) {
-    hints.push(
-      'To advertise to them: `baker accounts warm --output csv > warm.csv`, then `baker ads linkedin audiences create --name "Warm accounts" --type company-list --list-file warm.csv` (staged until publish).'
-    );
-  }
-  return hints;
-}
-var WARM_CSV_COLUMNS = ["companyName", "domain", "organizationUrn"];
-function warmAccountsCsv(rows) {
-  const lines = [toCsvRow(WARM_CSV_COLUMNS)];
-  for (const row of rows) {
-    const name = row.name.replace(/\s*[\r\n]+\s*/g, " ");
-    lines.push(toCsvRow([name, row.domain, `urn:li:organization:${row.orgId}`]));
-  }
-  return `${lines.join("\n")}
-`;
-}
-var plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
-function reachText(counts2) {
-  return `${counts2.reached} of ${counts2.total} reached, ${counts2.engaged} engaged`;
-}
-function targetsHints(summary, unreadable) {
-  if (summary === void 0) {
-    return [
-      "This Baker server does not narrow reports to target accounts yet: the rows cover every company the ads reached."
-    ];
-  }
-  const tiers = Object.entries(summary.byTier ?? {}).sort(([a], [b]) => a.localeCompare(b, "en", { numeric: true })).map(([tier, counts2]) => `tier ${tier}: ${reachText(counts2)}`);
-  const hints = [
-    `Target accounts: ${reachText(summary)}${tiers.length > 0 ? ` (${tiers.join("; ")})` : ""}. Rows and numbers cover the target accounts only.`
-  ];
-  const missed = summary.notReached.length;
-  if (missed > 0) {
-    hints.push(
-      `${plural(missed, "target account was", "target accounts were")} never reached in the period (targets.notReached). Check ${missed === 1 ? "its domain is the website on its LinkedIn page" : "their domains are the websites on their LinkedIn pages"}, or advertise to ${missed === 1 ? "it" : "them"} with a company list.`
-    );
-  }
-  if (unreadable.length > 0) {
-    const listed = unreadable.map((entry) => `"${entry}"`).join(", ");
-    hints.push(
-      `Skipped ${plural(unreadable.length, "entry", "entries")} of the targets file that ${unreadable.length === 1 ? "is" : "are"} not a website: ${listed}.`
-    );
-  }
-  return hints;
-}
-function withDealStatus(rows) {
-  return rows.map((row) => ({ ...row, dealStatus: accountDealStatus(row) }));
-}
-var counts = (row) => ({
-  month: row.month,
-  impressions: row.impressions,
-  clicks: row.clicks,
-  engagements: row.engagements
-});
-function unreachedHint(unreached, deals) {
-  if (unreached.length > 0) {
-    return `The LinkedIn ads have not reached LinkedIn company ${unreached.map((org) => org.orgId).join(", ")} in the months the nightly sync keeps (up to 24), so there is nothing to show. Check the id against \`baker accounts engagement\`, or try the company's website domain.`;
-  }
-  if (deals > 0) {
-    return `That company is in the CRM with ${deals === 1 ? "1 deal" : `${deals} deals`}, but the LinkedIn ads have not reached it in the months the nightly sync keeps, so none of its deals can count as influenced.`;
-  }
-  return "The ads have not reached that company, or it is named differently: try its LinkedIn id from `baker accounts engagement`.";
-}
-function companyView(data) {
-  const reachedOrgs = new Set(data.months.map((row) => row.orgId));
-  const orgs = data.orgs.filter((org) => reachedOrgs.has(org.orgId) || org.name !== "" || org.crmCompanyId !== null);
-  const months = data.months.filter((row) => row.campaignId === "").map((row) => ({ orgId: row.orgId, ...counts(row) }));
-  const byCampaign = [];
-  for (const row of data.months) {
-    if (row.campaignId === "") continue;
-    let entry = byCampaign.find((item) => item.orgId === row.orgId && item.campaignId === row.campaignId);
-    if (entry === void 0) {
-      entry = { orgId: row.orgId, campaignId: row.campaignId, campaignName: row.campaignName, months: [] };
-      byCampaign.push(entry);
-    }
-    entry.months.push(counts(row));
-  }
-  const hints = [];
-  const unreached = unreachedHint(
-    data.orgs.filter((org) => !orgs.includes(org)),
-    data.deals.length
-  );
-  if (orgs.length === 0) hints.push(unreached);
-  if (byCampaign.length > 0) {
-    hints.push(
-      "`months` are the company's totals. `byCampaign` splits the same numbers by campaign, and a company several campaigns reached shows up under each \u2014 never add byCampaign to the totals or to each other."
-    );
-  }
-  if (orgs.some((org) => org.matchConfidence === "low")) {
-    hints.push(
-      "The CRM match is only a guess (a subdomain or a name) until someone confirms it in Measure \u2192 Accounts."
-    );
-  }
-  if (data.rule !== void 0 && data.deals.length > 0) {
-    hints.push(
-      `\`influenced\` on each deal: ${data.rule.threshold}+ ${data.rule.metric} (\`touchValue\`) in the ${data.rule.lookbackMonths} months up to the month the deal was created (closed, for a won deal), counted from this company's months above.`
-    );
-  }
-  return { data: { orgs, months, byCampaign, deals: data.deals, ...data.rule ? { rule: data.rule } : {} }, hints };
-}
-
-// src/commands/accounts/index.ts
-function optionalNumber(raw) {
-  return typeof raw === "string" && raw.trim() !== "" ? Number(raw) : void 0;
-}
-function optionalString(raw) {
-  return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : void 0;
-}
-function failInvalidArgs(message) {
-  writeJson({ ok: false, error: { code: "INVALID_ARGS", message } });
-  process.exit(1);
-}
-function failInvalid(issues) {
-  failInvalidArgs(invalidArgsMessage(issues));
-}
-function outputFormat(args, supported) {
-  const format = optionalString(args.output) ?? "json";
-  const refusal = outputFormatRefusal(format, supported);
-  if (refusal !== null) failInvalidArgs(refusal);
-  return format;
-}
-var OUTPUT_ARG = {
-  type: "string",
-  description: "json|csv|jsonl|md (default json). csv/jsonl/md print the rows only; the summary and hints go to stderr",
-  required: false,
-  default: "json"
-};
-var RULE_ARGS = {
-  model: {
-    type: "string",
-    description: "Read this report with another influence model, for this call only (the saved settings stay): engagement (engagements), awareness (impressions) or intent (clicks)",
-    required: false
-  },
-  threshold: {
-    type: "string",
-    description: "Read this report with another threshold on the model's metric, for this call only (a whole number, 1 or more)",
-    required: false
-  }
-};
-function ruleInput(args) {
-  return { model: optionalString(args.model), threshold: optionalNumber(args.threshold) };
-}
-function moneyText(value) {
-  return Object.entries(value).map(([currency, amount]) => `${Math.round(amount)} ${currency}`).join(" + ");
-}
-function failAccounts(err) {
-  const refusal = err instanceof ApiError ? accountsRefusal(err.code, err.message) : null;
-  if (err instanceof ApiError && refusal !== null) {
-    writeJson({ ok: false, error: { code: refusal.code, message: err.message, fix: refusal.fix } });
-    process.exit(1);
-  }
-  failApi(err);
-}
-var WINDOW_ARGS = {
-  "last-months": {
-    type: "string",
-    description: "Calendar months to read, the current one included (1-24)",
-    required: false
-  },
-  start: { type: "string", description: "First day, YYYY-MM-DD (instead of --last-months)", required: false },
-  end: { type: "string", description: "Last day, YYYY-MM-DD (default today; needs --start)", required: false }
-};
-var TARGETS_ARG = {
-  targets: {
-    type: "string",
-    description: 'Only these target accounts: a .csv (a domain or website column; name and tier optional) or a .json file (["acme.com", \u2026] or [{"domain": "acme.com", "tier": 1}, \u2026]). Rows and numbers narrow to them, and `targets` says how many were reached and engaged, per tier, and which were never reached. Build one from the Knowledge with `node __tooling__/scripts/target-accounts.mjs --out targets.csv`',
-    required: false
-  }
-};
-function targetsInput(args) {
-  const path = optionalString(args.targets);
-  if (path === void 0) return null;
-  let read;
-  try {
-    read = readTargetsFile(path, readFileSync(path, "utf8"));
-  } catch (err) {
-    failInvalidArgs(`--targets: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  if (read.targets.length === 0) failInvalidArgs(`--targets: ${path} names no company website.`);
-  return read;
-}
-function withTargetsHints(hints, read, summary) {
-  return read === null ? hints : [...targetsHints(summary, read.unreadable), ...hints];
-}
-function windowInput(args) {
-  return {
-    lastMonths: optionalNumber(args["last-months"]),
-    start: optionalString(args.start),
-    end: optionalString(args.end)
-  };
-}
-var INFLUENCED_ARGS = {
-  basis: {
-    type: "string",
-    description: "pipeline (default): deals created in the period and not won. revenue: deals closed won in the period",
-    required: false,
-    default: "pipeline"
-  },
-  ...WINDOW_ARGS,
-  full: {
-    type: "boolean",
-    description: "Every deal in the period, influenced or not, instead of the influenced ones",
-    required: false,
-    default: false
-  },
-  ...RULE_ARGS,
-  ...TARGETS_ARG,
-  output: OUTPUT_ARG
-};
-var DEAL_TABLE_FIELDS = [
-  "dealId",
-  "dealName",
-  "companyName",
-  "domain",
-  "amount",
-  "currency",
-  "status",
-  "referenceAt",
-  "touchValue",
-  "firstTouchMonth",
-  "matchConfidence",
-  "influenced",
-  "crmCompanyId"
-];
-function influencedSummaryLine(data) {
-  const { summary, rule } = data;
-  const value = moneyText(summary.influencedValue) || "no amount";
-  return `${summary.influencedDeals} of ${summary.deals} ${data.basis} deals influenced (${value}) \u2014 ${rule.threshold}+ ${rule.metric} in the ${rule.lookbackMonths} months up to each deal, ${data.window.start} to ${data.window.end}.`;
-}
-registerSchema({
-  command: "accounts.influenced",
-  description: `Start here for 'what pipeline / revenue did our LinkedIn ads influence'. A deal is influenced when its company reached the company's influence rule (default: 3+ LinkedIn ad engagements) in the 12 months up to and including the month the deal was created (pipeline) or closed won (revenue). A labelled rule, not credit: never call it 'attributed' or split it. Returns {summary: {deals, influencedDeals, influencedValue per currency, lowConfidenceDeals, spend, valuePerSpend}, deals, lowConfidence}. Amounts in different currencies are never added. Default the last 12 calendar months. --model/--threshold read it with another rule for this call only ("what if we counted 5+ engagements"); --targets <file> narrows it to the target accounts' deals; --output csv|md|jsonl prints the deals.`,
-  args: INFLUENCED_ARGS
-});
-var influencedCommand = defineCommand({
-  meta: {
-    name: "influenced",
-    description: "Deals the LinkedIn ads influenced, with influenced pipeline or revenue. Example: baker accounts influenced --basis revenue --last-months 6"
-  },
-  args: INFLUENCED_ARGS,
-  run: async ({ args }) => {
-    const format = outputFormat(args, TABLE_OUTPUT_FORMATS);
-    const targets = targetsInput(args);
-    const parsed = accountsInfluencedRequestSchema.safeParse({
-      ...windowInput(args),
-      ...ruleInput(args),
-      basis: optionalString(args.basis),
-      full: Boolean(args.full),
-      targets: targets?.targets
-    });
-    if (!parsed.success) failInvalid(parsed.error.issues);
-    try {
-      const response = await apiPost("/api/accounts/influenced", parsed.data);
-      const hints = withTargetsHints(influencedHints(response.data), targets, response.data.targets);
-      if (format !== "json") {
-        const rows = influencedTableRows(response.data, parsed.data.full);
-        writeAdsOutput(rows, format, DEAL_TABLE_FIELDS, [influencedSummaryLine(response.data), ...hints]);
-        return;
-      }
-      writeJson({ ...response, meta: { count: response.data.deals.length }, ...hints.length > 0 ? { hints } : {} });
-    } catch (err) {
-      failAccounts(err);
-    }
-  }
-});
-var ENGAGEMENT_ARGS = {
-  ...WINDOW_ARGS,
-  "campaign-id": { type: "string", description: "Only this campaign's companies (numeric id)", required: false },
-  limit: {
-    type: "string",
-    description: `Companies per page, 1-${ACCOUNTS_ENGAGEMENT_MAX_LIMIT} (default 500)`,
-    required: false
-  },
-  page: {
-    type: "string",
-    description: "Which page to read, 1-based, most engaged first (default 1). pageInfo.hasMore says another page follows; pageInfo.total counts every company reached",
-    required: false
-  },
-  ...TARGETS_ARG,
-  output: OUTPUT_ARG
-};
-registerSchema({
-  command: "accounts.engagement",
-  description: "Every company the LinkedIn ads reached, most engaged first, with the period before for comparison, New/Rising flags, and where it stands in the CRM (matched company; dealStatus won > open > lost > none, lost meaning every deal it had was lost; lastLostAt). Default the last 3 calendar months. From the nightly sync, so it is fast and covers up to 24 months; for a live read of one ad account use `baker ads linkedin companies`. Paged: --limit companies per page, --page N; pageInfo {page, pageSize, total, hasMore}. --targets <file> keeps the target accounts only and adds `targets` {total, reached, engaged, notReached, byTier}.",
-  args: ENGAGEMENT_ARGS
-});
-function engagementInput(args, targets, limit) {
-  return {
-    ...windowInput(args),
-    campaignId: optionalString(args["campaign-id"])?.replace(/^urn:li:sponsoredCampaign:/, ""),
-    limit: limit ?? optionalNumber(args.limit),
-    page: limit === void 0 ? optionalNumber(args.page) : void 0,
-    targets: targets?.targets
-  };
-}
-var engagementCommand = defineCommand({
-  meta: {
-    name: "engagement",
-    description: "Companies the LinkedIn ads reached, with New/Rising flags and CRM status. Example: baker accounts engagement --last-months 3 --limit 50"
-  },
-  args: ENGAGEMENT_ARGS,
-  run: async ({ args }) => {
-    const format = outputFormat(args, TABLE_OUTPUT_FORMATS);
-    const targets = targetsInput(args);
-    const parsed = accountsEngagementRequestSchema.safeParse(engagementInput(args, targets));
-    if (!parsed.success) failInvalid(parsed.error.issues);
-    try {
-      const response = await apiPost("/api/accounts/engagement", parsed.data);
-      const hints = withTargetsHints(engagementHints(response.data, parsed.data), targets, response.data.targets);
-      if (format !== "json") {
-        writeAdsOutput(engagementTableRows(response.data.companies), format, ENGAGEMENT_TABLE_FIELDS, hints);
-        return;
-      }
-      const companies = withDealStatus(response.data.companies);
-      writeJson({
-        ...response,
-        data: { ...response.data, companies },
-        meta: { count: companies.length, ...response.data.pageInfo ? { total: response.data.pageInfo.total } : {} },
-        ...hints.length > 0 ? { hints } : {}
-      });
-    } catch (err) {
-      failAccounts(err);
-    }
-  }
-});
-var warmRuleSchema = z.object({
-  model: z.enum(INFLUENCE_MODEL_KINDS).optional(),
-  threshold: z.number().int().min(1).optional(),
-  min: z.number().int().min(0).optional()
-});
-var WARM_ARGS = {
-  ...WINDOW_ARGS,
-  "campaign-id": ENGAGEMENT_ARGS["campaign-id"],
-  min: {
-    type: "string",
-    description: "Least a company must have done this period on the rule's metric to count as warm (default: the company's influence threshold, e.g. 3 engagements; 0 keeps every New/Rising company)",
-    required: false
-  },
-  ...RULE_ARGS,
-  ...TARGETS_ARG,
-  output: {
-    type: "string",
-    description: "json (default) or csv \u2014 csv prints companyName,domain,organizationUrn, the file `baker ads linkedin audiences create --type company-list --list-file` takes",
-    required: false,
-    default: "json"
-  }
-};
-registerSchema({
-  command: "accounts.warm",
-  description: "Warm accounts: companies engaging with the LinkedIn ads more than in the period before (New: nothing before; Rising: engagements at least doubled) that reached the company's influence threshold this period (e.g. 3+ engagements; --min overrides, --min 0 drops it) and are not already somebody's deal: no open deal, never won (customers are left out), and no deal lost in the last 6 months (an older loss no longer counts). Default the current calendar month against the one before. `--output csv > warm.csv` writes a company list ready for `baker ads linkedin audiences create --type company-list --list-file warm.csv` (LinkedIn needs 300+ matched members to serve). --targets <file> keeps the warm target accounts only and adds `targets` (reached and engaged among them).",
-  args: WARM_ARGS
-});
-var warmCommand = defineCommand({
-  meta: {
-    name: "warm",
-    description: "Companies warming up that are not in pipeline, customers, or recently lost. Example: baker accounts warm --last-months 1 --output csv > warm.csv"
-  },
-  args: WARM_ARGS,
-  run: async ({ args }) => {
-    const format = outputFormat(args, ["json", "csv"]);
-    const rule = warmRuleSchema.safeParse({ ...ruleInput(args), min: optionalNumber(args.min) });
-    if (!rule.success) failInvalid(rule.error.issues);
-    const targets = targetsInput(args);
-    const input = engagementInput(args, targets, ACCOUNTS_ENGAGEMENT_MAX_LIMIT);
-    const parsed = accountsEngagementRequestSchema.safeParse(
-      input.start === void 0 && input.lastMonths === void 0 ? { ...input, lastMonths: 1 } : input
-    );
-    if (!parsed.success) failInvalid(parsed.error.issues);
-    try {
-      const response = await apiPost("/api/accounts/engagement", parsed.data);
-      const minimum = warmMinimum(response.data.rule, rule.data);
-      const warm = warmAccounts(response.data.companies, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), { minimum });
-      const hints = withTargetsHints(warmHints(response.data, warm, minimum), targets, response.data.targets);
-      if (format === "csv") {
-        process.stdout.write(warmAccountsCsv(warm));
-        for (const hint of hints) process.stderr.write(`${hint}
-`);
-        return;
-      }
-      writeJson({
-        ok: true,
-        data: {
-          window: response.data.window,
-          previousWindow: response.data.previousWindow,
-          minimum: minimum ?? null,
-          ...response.data.targets ? { targets: response.data.targets } : {},
-          companies: withDealStatus(warm)
-        },
-        meta: { count: warm.length },
-        ...hints.length > 0 ? { hints } : {}
-      });
-    } catch (err) {
-      failAccounts(err);
-    }
-  }
-});
-var COMPANY_ARGS = {
-  company: {
-    type: "positional",
-    description: "LinkedIn company id (1035), its urn:li:organization URN, or a website domain (acme.com)",
-    required: true
-  }
-};
-registerSchema({
-  command: "accounts.company",
-  description: "One company's story: its month-by-month totals (`months`), the same numbers split by LinkedIn campaign (`byCampaign` \u2014 overlapping, never add it to the totals), the CRM company it matched and how surely, and that company's deals, each with `touchValue` and `influenced` under the company's rule. Use it to show why a deal counts as influenced.",
-  args: COMPANY_ARGS
-});
-function companyRequest(raw) {
-  const value = raw.trim();
-  return /^(urn:li:organization:)?\d+$/.test(value) ? { orgId: value } : { domain: value };
-}
-var companyCommand = defineCommand({
-  meta: {
-    name: "company",
-    description: "One company's monthly LinkedIn ad activity and its deals. Example: baker accounts company acme.com"
-  },
-  args: COMPANY_ARGS,
-  run: async ({ args }) => {
-    const parsed = accountsCompanyRequestSchema.safeParse(companyRequest(String(args.company ?? "")));
-    if (!parsed.success) failInvalid(parsed.error.issues);
-    try {
-      const response = await apiPost("/api/accounts/company", parsed.data);
-      const view = companyView(response.data);
-      writeJson({ ok: true, data: view.data, ...view.hints.length > 0 ? { hints: view.hints } : {} });
-    } catch (err) {
-      failAccounts(err);
-    }
-  }
-});
-var CAMPAIGNS_ARGS = {
-  basis: INFLUENCED_ARGS.basis,
-  ...WINDOW_ARGS,
-  ...RULE_ARGS,
-  ...TARGETS_ARG,
-  output: OUTPUT_ARG
-};
-var CAMPAIGN_TABLE_FIELDS = [
-  "campaignId",
-  "campaignName",
-  "companiesReached",
-  "companiesEngaged",
-  "influencedDeals",
-  "influencedValue"
-];
-registerSchema({
-  command: "accounts.campaigns",
-  description: "Per LinkedIn campaign: companies reached and engaged in the period, and the influenced deals it touched in their lookback \u2014 pipeline (default: deals created and not won) or, with --basis revenue, deals closed won. Overlapping by design \u2014 a deal counts for every campaign that touched it, so the rows never sum to the total; read them as a comparison, not a split. Default the last 12 calendar months. --model/--threshold read it with another rule for this call only; --targets <file> counts the target accounts only.",
-  args: CAMPAIGNS_ARGS
-});
-var campaignsCommand = defineCommand({
-  meta: {
-    name: "campaigns",
-    description: "Companies reached and influenced pipeline or revenue per campaign. Example: baker accounts campaigns --basis revenue --last-months 6"
-  },
-  args: CAMPAIGNS_ARGS,
-  run: async ({ args }) => {
-    const format = outputFormat(args, TABLE_OUTPUT_FORMATS);
-    const targets = targetsInput(args);
-    const input = {
-      basis: optionalString(args.basis),
-      ...windowInput(args),
-      ...ruleInput(args),
-      targets: targets?.targets
-    };
-    const parsed = accountsCampaignsRequestSchema.safeParse(input);
-    if (!parsed.success) failInvalid(parsed.error.issues);
-    try {
-      const response = await apiPost("/api/accounts/campaigns", parsed.data);
-      const hints = withTargetsHints(
-        ["Campaign rows overlap: a deal counts for every campaign that touched it. Never add them up."],
-        targets,
-        response.data.targets
-      );
-      if (format !== "json") {
-        const rows = response.data.campaigns.map((row) => ({
-          ...row,
-          influencedValue: moneyText(row.influencedValue)
-        }));
-        writeAdsOutput(rows, format, CAMPAIGN_TABLE_FIELDS, hints);
-        return;
-      }
-      writeJson({ ...response, meta: { count: response.data.campaigns.length }, hints });
-    } catch (err) {
-      failAccounts(err);
-    }
-  }
-});
-var accountsCommand = defineCommand({
-  meta: {
-    name: "accounts",
-    description: "Account insights: which companies the LinkedIn ads are warming, and which CRM deals they influenced. Start with `baker accounts influenced` or `baker accounts warm`."
-  },
-  subCommands: {
-    influenced: influencedCommand,
-    engagement: engagementCommand,
-    warm: warmCommand,
-    company: companyCommand,
-    campaigns: campaignsCommand,
-    crm: () => import("./crm-VNAUSVC5.js").then((m) => m.crmCommand)
-  }
-});
-export {
-  accountsCommand
-};
-//# sourceMappingURL=accounts-IW62WBX5.js.map