@dench.com/cli 3.5.8-staging.350 → 3.6.0

package/lib/campaign-filters.ts

@@ -0,0 +1,141 @@
+export const SEARCH_LIST_FLAGS = [
+  ["--titles", "titles", "titles"],
+  ["--past-titles", "pastTitles", "pastTitles"],
+  ["--person-names", "personNames"],
+  ["--locations", "locations", "locations"],
+  ["--seniorities", "seniorities", "seniorities"],
+  ["--past-seniorities", "pastSeniorities", "pastSeniorities"],
+  ["--profile-keywords", "profileKeywords", "profileKeywords"],
+  ["--company-keywords", "companyKeywords", "companyKeywords"],
+  ["--industries", "industries", "industries"],
+  ["--functions", "jobFunctions", "functions"],
+  ["--sub-functions", "subFunctions", "subFunctions"],
+  ["--company-domains", "companyDomains"],
+  ["--company-names", "companyNames"],
+  ["--past-company-names", "pastCompanyNames"],
+  ["--company-hq", "companyHeadquarters", "companyHeadquarters"],
+  ["--company-types", "companyTypes", "companyTypes"],
+  ["--universities", "universities", "universities"],
+  ["--skills", "skills", "skills"],
+  ["--languages", "languages", "languages"],
+  ["--headcount", "headcountRanges", "headcount"],
+] as const;
+
+const EXCLUDE_ALIASES: Record<string, readonly string[]> = {
+  "--company-domains": ["--not-domains", "--exclude-domains"],
+};
+
+export function excludeFlagsFor(flag: string): string[] {
+  const name = flag.slice(2);
+  return [
+    `--not-${name}`,
+    `--exclude-${name}`,
+    ...(EXCLUDE_ALIASES[flag] ?? []),
+  ];
+}
+
+export const SEARCH_TEXT_FLAGS = [
+  ["--keywords", "keywords"],
+  ["--company-domain", "companyDomain"],
+] as const;
+
+export const SEARCH_RANGE_FLAGS = [
+  ["--years-in-role", "yearsInRole"],
+  ["--years-at-company", "yearsAtCompany"],
+  ["--days-since-job-change", "daysSinceJobChange"],
+  ["--founded-years", "foundedYears"],
+] as const;
+
+export const SEARCH_REQUEST_FLAGS = [
+  "--search",
+  "--filters",
+  "--people-file",
+  "--csv",
+  "--map",
+  "--list",
+  "--enrichment",
+  "--limit",
+  "--page-token",
+  "--preview",
+  "--exact",
+] as const;
+
+const SEARCH_FLAG_NAMES = new Set<string>([
+  ...SEARCH_REQUEST_FLAGS,
+  ...SEARCH_LIST_FLAGS.map(([flag]) => flag),
+  ...SEARCH_LIST_FLAGS.flatMap(([flag]) => excludeFlagsFor(flag)),
+  ...SEARCH_TEXT_FLAGS.map(([flag]) => flag),
+  ...SEARCH_RANGE_FLAGS.map(([flag]) => flag),
+]);
+
+export function usesSearchFlags(args: readonly string[]): boolean {
+  return args.some((token) => SEARCH_FLAG_NAMES.has(token));
+}
+
+export const FILTER_KEY_ALIASES: Record<string, string> = {
+  title: "titles",
+  jobtitle: "titles",
+  jobtitles: "titles",
+  role: "titles",
+  roles: "titles",
+  location: "locations",
+  country: "locations",
+  countries: "locations",
+  city: "locations",
+  cities: "locations",
+  region: "locations",
+  regions: "locations",
+  geo: "locations",
+  geography: "locations",
+  industry: "industries",
+  sector: "industries",
+  sectors: "industries",
+  vertical: "industries",
+  verticals: "industries",
+  seniority: "seniorities",
+  level: "seniorities",
+  levels: "seniorities",
+  headcount: "headcountRanges",
+  headcounts: "headcountRanges",
+  headcountrange: "headcountRanges",
+  companysize: "headcountRanges",
+  companysizes: "headcountRanges",
+  employees: "headcountRanges",
+  employeecount: "headcountRanges",
+  size: "headcountRanges",
+  sizes: "headcountRanges",
+  function: "jobFunctions",
+  functions: "jobFunctions",
+  jobfunction: "jobFunctions",
+  department: "jobFunctions",
+  departments: "jobFunctions",
+  subfunction: "subFunctions",
+  domain: "companyDomains",
+  domains: "companyDomains",
+  website: "companyDomains",
+  websites: "companyDomains",
+  company: "companyNames",
+  companies: "companyNames",
+  hq: "companyHeadquarters",
+  headquarters: "companyHeadquarters",
+  companyhq: "companyHeadquarters",
+  companylocation: "companyHeadquarters",
+  companylocations: "companyHeadquarters",
+  companytype: "companyTypes",
+  keyword: "keywords",
+  skill: "skills",
+  university: "universities",
+  school: "universities",
+  schools: "universities",
+  education: "universities",
+  language: "languages",
+  pasttitle: "pastTitles",
+  previoustitles: "pastTitles",
+  pastcompanies: "pastCompanyNames",
+  previouscompanies: "pastCompanyNames",
+  name: "fullName",
+  names: "personNames",
+  founded: "foundedYears",
+  foundedyear: "foundedYears",
+  exact: "exactMatch",
+};

package/lib/campaign-lines.ts

@@ -0,0 +1,217 @@
+export const MAX_LINES = 5;
+export const DEFAULT_LINE_CHARS = 200;
+export const LINE_CENTS_PER_PERSON = 3;
+
+const KEY_MAX = 40;
+const LINE_FIELDS = [
+  "key",
+  "label",
+  "instructions",
+  "prompt",
+  "fallback",
+  "fallbackFrom",
+  "maxChars",
+] as const;
+
+export type LineVariable = {
+  key: string;
+  label: string;
+  prompt: string;
+  fallback: string;
+  fallbackFrom?: string;
+  maxChars?: number;
+};
+
+export type LineTemplate = {
+  variables: LineVariable[];
+  context: { sells: string; offer?: string };
+};
+
+export class LinesFileError extends Error {}
+
+export function normalizedLineKey(key: string): string {
+  return key
+    .replace(/^(crm|person):/i, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "");
+}
+
+export function keyFromLabel(label: string): string {
+  const key = label
+    .normalize("NFKD")
+    .replace(/\p{M}+/gu, "")
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((word, index) =>
+      index === 0
+        ? word.toLowerCase()
+        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+    )
+    .join("")
+    .replace(/^[0-9]+/, "")
+    .slice(0, KEY_MAX);
+  return key || "line";
+}
+
+function uniqueKey(label: string, used: Set<string>): string {
+  const base = keyFromLabel(label);
+  if (!used.has(normalizedLineKey(base))) return base;
+  for (let suffix = 2; ; suffix += 1) {
+    const tail = String(suffix);
+    const key = `${base.slice(0, KEY_MAX - tail.length)}${tail}`;
+    if (!used.has(normalizedLineKey(key))) return key;
+  }
+}
+
+function labelKey(label: string): string {
+  return label.trim().replace(/\s+/g, " ").toLowerCase();
+}
+
+function text(
+  row: Record<string, unknown>,
+  field: string,
+  where: string,
+): string | undefined {
+  const value = row[field];
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "string")
+    throw new LinesFileError(`${where}.${field} must be text.`);
+  return value.trim() || undefined;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+export function linesTemplateFromFile(
+  parsed: unknown,
+  options: {
+    existing?: LineTemplate | null;
+    suggestedSells?: string;
+    source?: string;
+  } = {},
+): LineTemplate {
+  const source = options.source ?? "The lines file";
+  const root = record(parsed);
+  const rows = Array.isArray(parsed)
+    ? parsed
+    : Array.isArray(root?.lines)
+      ? (root?.lines as unknown[])
+      : Array.isArray(root?.variables)
+        ? (root?.variables as unknown[])
+        : null;
+  if (!rows)
+    throw new LinesFileError(
+      `${source} must be {"sells": "...", "lines": [{"label": "...", "instructions": "...", "fallback": "..."}]} or a JSON array of lines.`,
+    );
+  if (rows.length === 0)
+    throw new LinesFileError(
+      `${source} has no lines. To turn personalized lines off, run dench campaign personalize clear <campaign>.`,
+    );
+  if (rows.length > MAX_LINES)
+    throw new LinesFileError(
+      `${source} has ${rows.length} lines; a campaign can have up to ${MAX_LINES}.`,
+    );
+  const context = record(root?.context);
+  const sells =
+    (root ? text(root, "sells", "file") : undefined) ??
+    (context ? text(context, "sells", "context") : undefined) ??
+    options.existing?.context.sells ??
+    options.suggestedSells?.trim();
+  if (!sells)
+    throw new LinesFileError(
+      `${source} needs "sells": one or two sentences on what your company sells, so the writer knows what each line should lead to.`,
+    );
+  const offer =
+    (root ? text(root, "offer", "file") : undefined) ??
+    (context ? text(context, "offer", "context") : undefined);
+  const existingByLabel = new Map(
+    (options.existing?.variables ?? []).map((variable) => [
+      labelKey(variable.label),
+      variable.key,
+    ]),
+  );
+  const prepared = rows.map((value, index) => {
+    const where = `lines[${index}]`;
+    const row = record(value);
+    if (!row)
+      throw new LinesFileError(
+        `${where} must be an object like {"label": "Company hook", "instructions": "One sentence about ...", "fallback": "Your team caught my eye."}.`,
+      );
+    const unknown = Object.keys(row).filter(
+      (key) => !(LINE_FIELDS as readonly string[]).includes(key),
+    );
+    if (unknown.length)
+      throw new LinesFileError(
+        `${where} has ${unknown.join(", ")}, which a line does not have. Use: label, instructions, fallback, and optionally key, maxChars, fallbackFrom.`,
+      );
+    const label = text(row, "label", where);
+    const prompt =
+      text(row, "instructions", where) ?? text(row, "prompt", where);
+    const fallback = text(row, "fallback", where);
+    if (!label) throw new LinesFileError(`${where} needs a "label".`);
+    if (!prompt)
+      throw new LinesFileError(
+        `${where} ("${label}") needs "instructions": what the writer should say.`,
+      );
+    if (!fallback)
+      throw new LinesFileError(
+        `${where} ("${label}") needs a "fallback": the line sent when there is nothing specific to say.`,
+      );
+    const maxChars = row.maxChars;
+    if (
+      maxChars !== undefined &&
+      (typeof maxChars !== "number" || !Number.isInteger(maxChars))
+    )
+      throw new LinesFileError(
+        `${where} ("${label}"): "maxChars" must be a whole number of characters.`,
+      );
+    return {
+      key: text(row, "key", where),
+      label,
+      prompt,
+      fallback,
+      fallbackFrom: text(row, "fallbackFrom", where),
+      maxChars: maxChars as number | undefined,
+    };
+  });
+  const seenLabels = new Map<string, number>();
+  prepared.forEach((line, index) => {
+    const earlier = seenLabels.get(labelKey(line.label));
+    if (earlier !== undefined)
+      throw new LinesFileError(
+        `lines[${index}] has the same label as lines[${earlier}] ("${line.label}"); each line needs its own name.`,
+      );
+    seenLabels.set(labelKey(line.label), index);
+  });
+  const used = new Set<string>();
+  for (const line of prepared) {
+    const kept = line.key ?? existingByLabel.get(labelKey(line.label));
+    if (kept) used.add(normalizedLineKey(kept));
+  }
+  const keyOwners = new Map<string, number>();
+  const variables = prepared.map((line, index) => {
+    let key = line.key ?? existingByLabel.get(labelKey(line.label));
+    if (!key) {
+      key = uniqueKey(line.label, used);
+      used.add(normalizedLineKey(key));
+    }
+    const owner = keyOwners.get(normalizedLineKey(key));
+    if (owner !== undefined)
+      throw new LinesFileError(
+        `lines[${index}] and lines[${owner}] both use the key "${key}"; give each line its own key.`,
+      );
+    keyOwners.set(normalizedLineKey(key), index);
+    return {
+      key,
+      label: line.label,
+      prompt: line.prompt,
+      fallback: line.fallback,
+      ...(line.fallbackFrom ? { fallbackFrom: line.fallbackFrom } : {}),
+      ...(line.maxChars !== undefined ? { maxChars: line.maxChars } : {}),
+    };
+  });
+  return { variables, context: { sells, ...(offer ? { offer } : {}) } };
+}