@oxygen-agent/cli 1.982.3 → 1.1003.12

package/node_modules/@oxygen/formula/dist/value-cleaners.js

@@ -0,0 +1,358 @@
+/**
+ * Deterministic value cleaners for dirty GTM strings — company names, job
+ * titles, delimited lists, and email-address classification.
+ *
+ * Pure string functions with no I/O, no tenant context, and no dependencies,
+ * so the exact semantics that clean a cell in the worker also run in the
+ * browser (formula editor previews). Every list below is a fixed, auditable
+ * data set: nothing here calls a provider, spends a credit, or guesses with a
+ * model. When a deterministic list is not enough, the paid verifier columns
+ * are the upgrade — these helpers are the free first pass.
+ */
+import { PERSONAL_EMAIL_DOMAINS } from "@oxygen/shared/freemail-domains";
+// ---------------------------------------------------------------------------
+// Shared text helpers
+// ---------------------------------------------------------------------------
+/** Zero-width joiners, variation selectors, and the BOM — invisible, never meaningful in a cell. */
+const INVISIBLE_PATTERN = /[​-‍⁠︎️⃣]/g;
+/**
+ * Emoji, pictographs, and symbol runs. Deliberately Unicode-property based:
+ * a byte-range or "non-ASCII" filter would eat accented letters, and GTM data
+ * is full of Müller, Ørsted, and Škoda.
+ */
+const PICTOGRAPH_PATTERN = /[\p{Extended_Pictographic}\p{Emoji_Presentation}\p{Emoji_Modifier}\p{So}]/gu;
+/** Leading/trailing punctuation, symbols, quotes, and whitespace. Inner punctuation is preserved. */
+const OUTER_NOISE_PATTERN = /^[\s\p{P}\p{S}]+|[\s\p{P}\p{S}]+$/gu;
+function toText(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    try {
+        return JSON.stringify(value) ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+function collapseWhitespace(value) {
+    return value.replace(INVISIBLE_PATTERN, "").replace(/\s+/gu, " ").trim();
+}
+function trimOuterNoise(value) {
+    return value.replace(OUTER_NOISE_PATTERN, "");
+}
+/** True when every cased letter in the text is upper-case (digits/punctuation ignored). */
+export function isAllCaps(value) {
+    let sawCasedLetter = false;
+    for (const char of value) {
+        if (!/\p{L}/u.test(char))
+            continue;
+        const lower = char.toLowerCase();
+        const upper = char.toUpperCase();
+        if (lower === upper)
+            continue; // caseless script (CJK, etc.) — not evidence either way
+        sawCasedLetter = true;
+        if (char !== upper)
+            return false;
+    }
+    return sawCasedLetter;
+}
+/** Capitalizes the first letter of every word and lowercases the rest (Unicode-aware). */
+export function titleCaseWords(value) {
+    return value.replace(/(\p{L})(\p{L}*)/gu, (_match, first, rest) => first.toUpperCase() + rest.toLowerCase());
+}
+// ---------------------------------------------------------------------------
+// Company names
+// ---------------------------------------------------------------------------
+/**
+ * Legal/corporate suffixes, stored as punctuation-free lower-case keys so
+ * "L.L.C.", "llc", and "LLC," all reduce to `llc`. Multi-word suffixes are
+ * joined ("pty ltd" → `ptyltd`) and matched against the trailing 1–3 tokens.
+ */
+export const COMPANY_LEGAL_SUFFIX_KEYS = new Set([
+    "inc", "incorporated", "corp", "corporation", "co", "company",
+    "ltd", "limited", "llc", "llp", "lp", "plc",
+    "gmbh", "ag", "sa", "sas", "sarl", "srl", "spa",
+    "bv", "nv", "oy", "ab", "as", "pty", "kg", "kk", "pte",
+    "sdnbhd", "ptyltd", "pteltd",
+    "ltda", "ug", "ev", "ou", "sro", "spzoo", "zrt", "kft", "doo",
+    "aps", "hf", "ehf", "ltee",
+]);
+/** The longest suffix key measured in whitespace-separated tokens ("sp. z o.o."). */
+const MAX_SUFFIX_TOKENS = 3;
+/** Separators after which a company string turns into a tagline, not a name. */
+const SHORT_FORM_SEPARATORS = [" - ", " – ", " — ", " | ", ":", " / ", "("];
+const SHORT_FORM_MAX_WORDS = 3;
+function suffixKey(token) {
+    return token.toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+}
+function stripLegalSuffixes(tokens) {
+    let remaining = [...tokens];
+    // Bounded: every pass removes at least one token, so the token count is the budget.
+    for (let pass = 0; pass < tokens.length; pass += 1) {
+        while (remaining.length > 1 && suffixKey(remaining[remaining.length - 1] ?? "") === "") {
+            remaining = remaining.slice(0, -1);
+        }
+        let matched = false;
+        for (let span = Math.min(MAX_SUFFIX_TOKENS, remaining.length - 1); span >= 1; span -= 1) {
+            const key = remaining.slice(remaining.length - span).map(suffixKey).join("");
+            if (!key || !COMPANY_LEGAL_SUFFIX_KEYS.has(key))
+                continue;
+            remaining = remaining.slice(0, remaining.length - span);
+            matched = true;
+            break;
+        }
+        if (!matched)
+            break;
+    }
+    return remaining;
+}
+function cutAtShortFormSeparator(value) {
+    let cut = value.length;
+    for (const separator of SHORT_FORM_SEPARATORS) {
+        const index = value.indexOf(separator);
+        if (index > 0 && index < cut)
+            cut = index;
+    }
+    return value.slice(0, cut);
+}
+/**
+ * Canonical company name: legal suffixes removed, stray punctuation and quotes
+ * trimmed, whitespace collapsed. Casing is the author's unless the whole name
+ * shouts ("ACME CORP." → "Acme"), because "hubspot" is how that company writes
+ * itself. `short` additionally cuts a tagline after a separator and keeps at
+ * most three words — the form that fits in an email's first sentence.
+ *
+ * Blank input returns null.
+ */
+export function normalizeCompanyName(value, mode = "display") {
+    const raw = collapseWhitespace(toText(value).replace(PICTOGRAPH_PATTERN, ""));
+    if (!raw)
+        return null;
+    const base = mode === "short" ? collapseWhitespace(cutAtShortFormSeparator(raw)) : raw;
+    if (!base)
+        return null;
+    const tokens = stripLegalSuffixes(base.split(" ").filter(Boolean));
+    let cleaned = collapseWhitespace(trimOuterNoise(tokens.join(" ")));
+    if (!cleaned)
+        cleaned = collapseWhitespace(trimOuterNoise(base));
+    if (!cleaned)
+        return null;
+    if (mode === "short") {
+        const words = cleaned.split(" ").filter(Boolean);
+        if (words.length > SHORT_FORM_MAX_WORDS) {
+            cleaned = words.slice(0, SHORT_FORM_MAX_WORDS).join(" ");
+        }
+    }
+    return isAllCaps(cleaned) ? titleCaseWords(cleaned) : cleaned;
+}
+// ---------------------------------------------------------------------------
+// Job titles
+// ---------------------------------------------------------------------------
+/**
+ * Recruiting and self-promotion phrases that ride along in a scraped headline.
+ * Longest first so "we're hiring" is consumed before the bare "hiring".
+ */
+export const JOB_TITLE_SLOGANS = [
+    "we are hiring",
+    "we're hiring",
+    "join our team",
+    "open to work",
+    "let's connect",
+    "looking for",
+    "now hiring",
+    "opentowork",
+    "join us",
+    "dm me",
+    "hiring",
+];
+const SLOGAN_PATTERNS = JOB_TITLE_SLOGANS
+    .slice()
+    .sort((a, b) => b.length - a.length)
+    .map((phrase) => {
+    const body = phrase
+        .split("")
+        .map((char) => {
+        if (char === " ")
+            return "\\s+";
+        if (char === "'")
+            return "['’‘ʼ´]";
+        return char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    })
+        .join("");
+    // No lookbehind: Safari shipped it late and this engine runs in the browser.
+    return new RegExp(`(^|[^\\p{L}\\p{N}])(?:${body})(?![\\p{L}\\p{N}])`, "giu");
+});
+/**
+ * Separators that join a real title to a second clause. A bare `-`, `,`, `/`,
+ * or `&` is NOT one of them: "Account Executive - EMEA", "Sr. Director, Demand
+ * Generation", and "Director of Importing/Exporting" are whole titles.
+ */
+const JOB_TITLE_SEPARATOR_PATTERN = /\s*\|\s*|\s*[•·]\s*|\s*::\s*|\s+[—–]\s+/u;
+/**
+ * Canonical job title: emoji, hashtags, parentheticals, and hiring slogans
+ * removed, then only the first clause of a separator-joined headline kept.
+ * All-caps titles are title-cased; every other casing is the author's.
+ *
+ * Blank input, or input that was nothing but noise, returns null.
+ */
+export function cleanJobTitle(value) {
+    let text = toText(value);
+    if (!text.trim())
+        return null;
+    text = text.replace(PICTOGRAPH_PATTERN, "").replace(INVISIBLE_PATTERN, "");
+    // Parentheticals, innermost-out; bounded so a pathological paste cannot spin.
+    for (let pass = 0; pass < 4; pass += 1) {
+        const next = text.replace(/\([^()]*\)/g, " ").replace(/\[[^[\]]*\]/g, " ");
+        if (next === text)
+            break;
+        text = next;
+    }
+    text = text.replace(/#[\p{L}\p{N}_-]+/gu, " ");
+    for (const pattern of SLOGAN_PATTERNS)
+        text = text.replace(pattern, "$1");
+    text = collapseWhitespace(text);
+    const segments = text.split(JOB_TITLE_SEPARATOR_PATTERN).map((part) => (part ?? "").trim());
+    const chosen = segments.find((part) => /[\p{L}\p{N}]/u.test(part)) ?? segments[0] ?? "";
+    const cleaned = collapseWhitespace(trimOuterNoise(chosen));
+    if (!cleaned)
+        return null;
+    return isAllCaps(cleaned) ? titleCaseWords(cleaned) : cleaned;
+}
+// ---------------------------------------------------------------------------
+// Delimited lists
+// ---------------------------------------------------------------------------
+/** Tried in order when no separator is given; the first one present wins. */
+const LIST_DELIMITERS = ["\n", ";", "|", ","];
+function cleanListParts(parts) {
+    const seen = new Set();
+    const out = [];
+    for (const part of parts) {
+        const text = collapseWhitespace(toText(part));
+        if (!text || seen.has(text))
+            continue;
+        seen.add(text);
+        out.push(text);
+    }
+    return out;
+}
+/**
+ * Turns one messy cell into a clean array: trimmed, blank-free, de-duplicated
+ * in first-seen order. An existing array or a JSON-encoded array is cleaned in
+ * place; a string is split on the given separator, or on the first delimiter
+ * actually present (newline, `;`, `|`, `,`) when none is given.
+ *
+ * Blank input returns an empty array.
+ */
+export function splitDelimitedList(value, separator) {
+    if (Array.isArray(value))
+        return cleanListParts(value);
+    if (value === null || value === undefined)
+        return [];
+    const text = typeof value === "string" ? value : toText(value);
+    const trimmed = text.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed))
+                return cleanListParts(parsed);
+        }
+        catch {
+            // Not JSON after all — fall through to delimiter splitting.
+        }
+    }
+    const explicit = typeof separator === "string" ? separator : "";
+    if (explicit)
+        return cleanListParts(trimmed.split(explicit));
+    if (/\r?\n/.test(trimmed))
+        return cleanListParts(trimmed.split(/\r?\n/));
+    for (const delimiter of LIST_DELIMITERS) {
+        if (delimiter !== "\n" && trimmed.includes(delimiter)) {
+            return cleanListParts(trimmed.split(delimiter));
+        }
+    }
+    return cleanListParts([trimmed]);
+}
+// ---------------------------------------------------------------------------
+// Email classification
+// ---------------------------------------------------------------------------
+/**
+ * Consumer mailbox providers — a person, not a company domain. Re-exported from
+ * `@oxygen/shared/freemail-domains`, which is now the ONE list; this module used to
+ * carry its own 101-entry copy and was the best-maintained of eight divergent forks.
+ * Its entries survive as the bulk of the shared broad tier.
+ */
+// Aliased rather than `export … from`, because this module also USES the set locally
+// (see classifyDomain below) and a re-export creates no local binding.
+export const FREE_MAIL_DOMAINS = PERSONAL_EMAIL_DOMAINS;
+/** Throwaway inbox providers — never worth a send, never worth a credit. */
+export const DISPOSABLE_EMAIL_DOMAINS = new Set([
+    "mailinator.com", "guerrillamail.com", "guerrillamail.net",
+    "10minutemail.com", "10minutemail.net",
+    "tempmail.com", "temp-mail.org", "temp-mail.io", "tempr.email",
+    "yopmail.com", "yopmail.fr", "trashmail.com", "trashmail.me",
+    "getnada.com", "dispostable.com", "maildrop.cc", "sharklasers.com",
+    "throwawaymail.com", "fakeinbox.com", "mohmal.com", "mailnesia.com",
+    "spamgourmet.com", "discard.email", "mintemail.com", "emailondeck.com",
+    "burnermail.io", "tempail.com", "mytemp.email", "moakt.com",
+    "tmpmail.org", "tmpmail.net", "minutemail.com", "mailcatch.com",
+    "spam4.me", "harakirimail.com", "jetable.org", "mailexpire.com",
+    "throwam.com", "tempinbox.com", "inboxkitten.com",
+]);
+/** Shared-inbox local parts — a department, not a person. */
+export const ROLE_EMAIL_LOCAL_PARTS = new Set([
+    "info", "sales", "support", "help", "admin", "administrator",
+    "contact", "hello", "hi", "team", "office",
+    "billing", "invoices", "accounts", "accounting", "finance",
+    "marketing", "hr", "jobs", "careers", "recruiting",
+    "press", "media", "pr", "legal", "privacy", "security", "abuse",
+    "postmaster", "webmaster", "hostmaster",
+    "noreply", "no-reply", "donotreply", "do-not-reply",
+    "newsletter", "notifications", "notification",
+    "mail", "mailer-daemon", "service", "services",
+    "customerservice", "customer-service",
+    "enquiries", "inquiries", "enquiry", "inquiry",
+    "orders", "order", "partners", "partnerships",
+    "feedback", "welcome", "community",
+    "dev", "devops", "it", "ops", "engineering",
+    "alerts", "subscriptions",
+]);
+const EMAIL_SYNTAX_PATTERN = /^[^\s@,;:<>"'()[\]\\]+@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
+/** A domain matches a list when it IS a listed domain or a subdomain of one (mail.yahoo.com). */
+function matchesDomainList(domain, list) {
+    if (list.has(domain))
+        return true;
+    const labels = domain.split(".");
+    for (let index = 1; index < labels.length - 1; index += 1) {
+        if (list.has(labels.slice(index).join(".")))
+            return true;
+    }
+    return false;
+}
+/**
+ * Classifies an email address from OXYGEN's built-in lists, in precedence
+ * order: a throwaway domain wins, then a shared-inbox local part, then a
+ * consumer mailbox provider, and anything left is a company address.
+ *
+ * Blank or syntactically invalid input returns null.
+ */
+export function classifyEmailType(value) {
+    const email = toText(value).trim().toLowerCase();
+    if (!email || !EMAIL_SYNTAX_PATTERN.test(email))
+        return null;
+    const at = email.lastIndexOf("@");
+    const localPart = email.slice(0, at);
+    const domain = email.slice(at + 1);
+    if (matchesDomainList(domain, DISPOSABLE_EMAIL_DOMAINS))
+        return "disposable";
+    const untagged = localPart.split("+")[0] ?? localPart;
+    if (ROLE_EMAIL_LOCAL_PARTS.has(untagged) || ROLE_EMAIL_LOCAL_PARTS.has(localPart))
+        return "role";
+    if (matchesDomainList(domain, FREE_MAIL_DOMAINS))
+        return "personal";
+    return "work";
+}

package/node_modules/@oxygen/shared/dist/array-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Small array helpers shared across every OXYGEN package.
+ */
+/** Split `values` into consecutive slices of at most `size` entries. */
+export declare function chunk<T>(values: T[], size: number): T[][];

package/node_modules/@oxygen/shared/dist/array-utils.js

@@ -0,0 +1,11 @@
+/**
+ * Small array helpers shared across every OXYGEN package.
+ */
+/** Split `values` into consecutive slices of at most `size` entries. */
+export function chunk(values, size) {
+    const chunks = [];
+    for (let index = 0; index < values.length; index += size) {
+        chunks.push(values.slice(index, index + size));
+    }
+    return chunks;
+}