@oxygen-agent/cli 1.948.1 → 1.987.20

package/node_modules/@oxygen/cli-ugc/dist/field-parser.d.ts

@@ -0,0 +1,7 @@
+export type Field = {
+    name: string;
+    kind: string;
+    description: string;
+    required: boolean;
+};
+export declare function parseField(value: unknown, field: Field): unknown;

package/node_modules/@oxygen/cli-ugc/dist/field-parser.js

@@ -0,0 +1,25 @@
+export function parseField(value, field) {
+    if (field.kind === "array" || field.kind === "object") {
+        const parsed = JSON.parse(String(value));
+        if (field.kind === "array"
+            ? !Array.isArray(parsed) ||
+                !parsed.every((item) => typeof item === "string")
+            : !parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error(`${field.name} must be a JSON ${field.kind === "array" ? "array of strings" : "object"}.`);
+        return parsed;
+    }
+    if (field.kind === "number") {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed) || parsed < 0)
+            throw new Error(`${field.name} must be a nonnegative finite number.`);
+        return parsed;
+    }
+    if (field.kind === "boolean") {
+        if (value === true || value === "true")
+            return true;
+        if (value === false || value === "false")
+            return false;
+        throw new Error(`${field.name} must be true or false.`);
+    }
+    return value;
+}

package/node_modules/@oxygen/cli-ugc/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "commander";
+/** The CLI owns authentication, transport, output and error presentation. */
+export interface UgcCommandDependencies {
+    request: (path: string, options?: {
+        method: "POST";
+        body: Record<string, unknown>;
+        idempotencyKey?: string;
+    }) => Promise<unknown>;
+    handle: (command: string, options: {
+        json?: boolean;
+    }, action: () => Promise<unknown>) => Promise<void>;
+}
+/** Register the existing UGC command tree without performing requests. */
+export declare function registerUgcCommands(program: Command, dependencies: UgcCommandDependencies): void;

package/node_modules/@oxygen/cli-ugc/dist/index.js

@@ -0,0 +1,5 @@
+import { registerUgcCommands as registerCommands } from "./commands.js";
+/** Register the existing UGC command tree without performing requests. */
+export function registerUgcCommands(program, dependencies) {
+    registerCommands(program, dependencies);
+}

package/node_modules/@oxygen/cli-ugc/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@oxygen/cli-ugc",
+  "version": "0.0.0",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {}
+}

package/node_modules/@oxygen/formula/dist/expression.js

@@ -435,6 +435,13 @@ function readStringLiteral(expression, start, quote) {
         expression,
     });
 }
+/**
+ * Only the escapes the language actually defines are decoded. Everything else
+ * is preserved verbatim, backslash included, because a formula string literal
+ * is the only way to write a regex pattern: collapsing an unknown escape to the
+ * bare character silently turned `"\\s+"` into `s+`, so `regex_replace(x, "\\s+", "_")`
+ * matched a literal "s" and the pattern looked broken with nothing to debug.
+ */
 function decodeEscapedCharacter(char) {
     switch (char) {
         case "n":
@@ -443,8 +450,14 @@ function decodeEscapedCharacter(char) {
             return "\r";
         case "t":
             return "\t";
+        case "\\":
+            return "\\";
+        case "\"":
+            return "\"";
+        case "'":
+            return "'";
         default:
-            return char;
+            return `\\${char}`;
     }
 }
 function readNumberLiteral(expression, start) {

package/node_modules/@oxygen/formula/dist/formula-functions.js

@@ -1,6 +1,7 @@
 import { OxygenError } from "@oxygen/shared/cli-result";
 import { walkJsonPath } from "@oxygen/shared/json-path";
 import { normalizeDomain, normalizeEmail, normalizeLinkedinUrl, } from "./value-normalizers.js";
+import { classifyEmailType, cleanJobTitle, normalizeCompanyName, splitDelimitedList, } from "./value-cleaners.js";
 // Pattern LENGTH is not a safety bound and never was -- catastrophic backtracking
 // is a function of pattern SHAPE, and `(a+)+$` hangs at 6 characters, so 256 already
 // permitted an unbounded hang while rejecting harmless long literals. The real bound
@@ -129,7 +130,8 @@ function compileFormulaRegex(pattern, functionName, flags) {
         return new RegExp(pattern, flags);
     }
     catch (error) {
-        throw formulaExpressionError("Invalid regular-expression pattern.", {
+        throw formulaExpressionError("Invalid regular-expression pattern. Patterns use JavaScript RegExp syntax without flags:"
+            + " inline modifiers such as (?i) are not supported — apply lower() to the input or spell out both cases.", {
             function: functionName,
             pattern,
             parse_error: error instanceof Error ? error.message : String(error),
@@ -638,6 +640,46 @@ const SPECS = [
             return asText(args[0]).includes(asText(args[1]));
         },
     }),
+    spec({
+        name: "normalize_company_name",
+        category: "string",
+        signature: "normalize_company_name(text, mode?)",
+        description: "Canonical company name: legal suffixes removed (Inc, Ltd, GmbH, Pty Ltd, sp. z o.o., …, repeatedly), stray punctuation and quotes trimmed, whitespace collapsed, \"&\" and apostrophes kept. Casing is the author’s unless the whole name is upper-case, which is title-cased. mode \"short\" (default \"display\") also drops a tagline after \" - \", \" | \", \":\", \" / \" or \"(\" and keeps at most the first three words, for use in a first sentence. Blank input returns null.",
+        minArgs: 1,
+        maxArgs: 2,
+        examples: [
+            { expression: "normalize_company_name(\"Acme, Inc.\")", result: "Acme" },
+            { expression: "normalize_company_name(\"ACME CORP.\")", result: "Acme" },
+            { expression: "normalize_company_name(\"Northwind Traders LLC - Logistics\", \"short\")", result: "Northwind Traders" },
+        ],
+        evaluate: (args) => {
+            if (isBlankFormulaValue(args[0]))
+                return null;
+            const mode = isBlankFormulaValue(args[1]) ? "display" : asText(args[1]).trim().toLowerCase();
+            if (mode !== "display" && mode !== "short") {
+                throw formulaExpressionError("Unsupported company-name mode.", {
+                    function: "normalize_company_name",
+                    mode: args[1],
+                    supported: ["display", "short"],
+                });
+            }
+            return normalizeCompanyName(asText(args[0]), mode);
+        },
+    }),
+    spec({
+        name: "clean_job_title",
+        category: "string",
+        signature: "clean_job_title(text)",
+        description: "Strips emoji, symbol runs, hashtags, parentheticals and hiring slogans (\"we’re hiring\", \"open to work\", \"looking for\", \"dm me\", …) from a scraped headline, then keeps only the first clause when it is joined by \" | \", \" • \", \" · \", \" — \", \" – \" or \" :: \". A bare \"-\", \",\", \"/\" or \"&\" never cuts, so \"Account Executive - EMEA\" and \"Director of Importing/Exporting\" survive whole. All-caps titles are title-cased; any other casing is the author’s. Blank or noise-only input returns null.",
+        minArgs: 1,
+        maxArgs: 1,
+        examples: [
+            { expression: "clean_job_title(\"VP of Sales 🚀 | We’re hiring!\")", result: "VP of Sales" },
+            { expression: "clean_job_title(\"Head of Growth (ex-Google)\")", result: "Head of Growth" },
+            { expression: "clean_job_title(\"Sr. Director, Demand Generation — Hiring SDRs!\")", result: "Sr. Director, Demand Generation" },
+        ],
+        evaluate: (args) => (isBlankFormulaValue(args[0]) ? null : cleanJobTitle(asText(args[0]))),
+    }),
     // --- number ----------------------------------------------------------------
     spec({
         name: "number",
@@ -911,6 +953,21 @@ const SPECS = [
         examples: [{ expression: "normalize_linkedin_url(\"https://linkedin.com/in/Ada/\")", result: "https://linkedin.com/in/ada" }],
         evaluate: (args) => blankToNull(args[0], (input) => normalizeLinkedinUrl(asText(input))),
     }),
+    spec({
+        name: "email_type",
+        category: "url_email",
+        signature: "email_type(email)",
+        description: "Classifies an address as \"disposable\", \"role\", \"personal\" (a consumer mailbox provider) or \"work\", from OXYGEN’s built-in domain and shared-inbox lists, in that precedence. Subdomains count as their parent domain and a +tag is ignored. Blank or syntactically invalid input returns null. When a fixed list is not enough, the paid bounceban.check verifier adds live username/domain typing and syntax validity for catch-all and SEG domains.",
+        minArgs: 1,
+        maxArgs: 1,
+        examples: [
+            { expression: "email_type(\"jane@gmail.com\")", result: "personal" },
+            { expression: "email_type(\"info@stripe.com\")", result: "role" },
+            { expression: "email_type(\"alice@mailinator.com\")", result: "disposable" },
+            { expression: "email_type(\"mark@acme.com\")", result: "work" },
+        ],
+        evaluate: (args) => (isBlankFormulaValue(args[0]) ? null : classifyEmailType(asText(args[0]))),
+    }),
     // --- array -----------------------------------------------------------------
     spec({
         name: "first",
@@ -989,6 +1046,19 @@ const SPECS = [
             return result;
         },
     }),
+    spec({
+        name: "to_json_list",
+        category: "array",
+        signature: "to_json_list(text, separator?)",
+        description: "Turns one messy cell into a clean array: every part trimmed, blanks dropped, duplicates removed in first-seen order. Without a separator the delimiter is auto-detected (newline, then \";\", then \"|\", then \",\"; otherwise a single item). An existing array or a JSON-encoded array string is cleaned in place. Blank input returns an empty array. Use split() when you want the raw parts, including blanks and duplicates.",
+        minArgs: 1,
+        maxArgs: 2,
+        examples: [
+            { expression: "to_json_list(\"fintech, payments,saas\")", result: ["fintech", "payments", "saas"] },
+            { expression: "to_json_list(\"growth;plg\")", result: ["growth", "plg"] },
+        ],
+        evaluate: (args) => splitDelimitedList(args[0], isBlankFormulaValue(args[1]) ? null : asText(args[1])),
+    }),
     // --- json ------------------------------------------------------------------
     spec({
         name: "path",

package/node_modules/@oxygen/formula/dist/index.d.ts

@@ -14,4 +14,5 @@ export { isRecord } from "./coerce.js";
 export * from "./evaluate.js";
 export * from "./expression.js";
 export * from "./formula-functions.js";
+export * from "./value-cleaners.js";
 export * from "./value-normalizers.js";

package/node_modules/@oxygen/formula/dist/index.js

@@ -14,4 +14,5 @@ export { isRecord } from "./coerce.js";
 export * from "./evaluate.js";
 export * from "./expression.js";
 export * from "./formula-functions.js";
+export * from "./value-cleaners.js";
 export * from "./value-normalizers.js";

package/node_modules/@oxygen/formula/dist/value-cleaners.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 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.
+ */
+/** True when every cased letter in the text is upper-case (digits/punctuation ignored). */
+export declare function isAllCaps(value: string): boolean;
+/** Capitalizes the first letter of every word and lowercases the rest (Unicode-aware). */
+export declare function titleCaseWords(value: string): string;
+/**
+ * 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 declare const COMPANY_LEGAL_SUFFIX_KEYS: ReadonlySet<string>;
+export type CompanyNameMode = "display" | "short";
+/**
+ * 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 declare function normalizeCompanyName(value: unknown, mode?: CompanyNameMode): string | null;
+/**
+ * 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 declare const JOB_TITLE_SLOGANS: readonly string[];
+/**
+ * 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 declare function cleanJobTitle(value: unknown): string | null;
+/**
+ * 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 declare function splitDelimitedList(value: unknown, separator?: string | null): string[];
+/** Consumer mailbox providers — a person, not a company domain. */
+export declare const FREE_MAIL_DOMAINS: ReadonlySet<string>;
+/** Throwaway inbox providers — never worth a send, never worth a credit. */
+export declare const DISPOSABLE_EMAIL_DOMAINS: ReadonlySet<string>;
+/** Shared-inbox local parts — a department, not a person. */
+export declare const ROLE_EMAIL_LOCAL_PARTS: ReadonlySet<string>;
+export type EmailType = "disposable" | "role" | "personal" | "work";
+/**
+ * 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 declare function classifyEmailType(value: unknown): EmailType | null;