salesprompter-cli 0.1.22 → 0.1.23

package/README.md

@@ -33,6 +33,12 @@ salesprompter auth:whoami
 # Product/category to leads workflow
 salesprompter salesnav:from-product-category --input "https://www.linkedin.com/company/example/"
 
+# Build Instantly-ready Deel outreach batches with German vs English splits
+salesprompter leadlists:deel-outreach:bq --market global --out-dir ./data/deel-outreach
+
+# Export the Supabase Sales Navigator Deel corpus into German vs English backlog files
+salesprompter salesnav:deel-locale-export --org-id "<org-id>" --out-dir ./data/deel-salesnav
+
 # Run a Sales Navigator crawl from a query URL
 salesprompter salesnav:crawl --query-url "https://www.linkedin.com/sales/search/people?query=..."
 

package/dist/cli.js

@@ -14,6 +14,8 @@ import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWi
 import { buildBigQueryLeadLookupSql, executeBigQuerySql, normalizeBigQueryLeadRows, runBigQueryQuery, runBigQueryRows } from "./bigquery.js";
 import { AccountProfileSchema, EnrichedLeadSchema, IcpSchema, LeadSchema, ScoredLeadSchema, SyncTargetSchema } from "./domain.js";
 import { auditDomainDecisions, buildDomainfinderBacklogQueries, buildDomainfinderCandidatesSql, buildDomainfinderInputSql, buildDomainfinderWritebackSql, buildExistingDomainRepairSql, buildExistingDomainAuditQueries, compareDomainSelectionStrategies, selectBestDomains } from "./domainfinder.js";
+import { buildDeelSalesNavCsvHeader, buildDeelSalesNavCsvLines, isDeelRelevantSalesNavTitle, normalizeDeelSalesNavRow } from "./deel-salesnav.js";
+import { buildDeelOutreachExportSql, buildDeelOutreachPack, normalizeDeelOutreachRows } from "./deel-outreach.js";
 import { buildDirectPathLeadExportSql, normalizeDirectPathRows, segmentDirectPathRows } from "./direct-path.js";
 import { AccountLeadProvider, DryRunSyncProvider, HeuristicCompanyProvider, HeuristicEnrichmentProvider, HeuristicPeopleSearchProvider, HeuristicScoringProvider, RoutedSyncProvider } from "./engine.js";
 import { analyzeHistoricalQueries } from "./historical-queries.js";
@@ -359,6 +361,24 @@ function slugify(value) {
         .replace(/^-+|-+$/g, "")
         .replace(/-{2,}/g, "-");
 }
+function resolveSalesNavigatorSupabaseConfig(env = process.env) {
+    const supabaseUrl = env.SALESPROMPTER_SUPABASE_URL?.trim() || env.NEXT_PUBLIC_SUPABASE_URL?.trim() || "";
+    const supabaseServiceRoleKey = env.SUPABASE_SERVICE_ROLE_KEY?.trim() || "";
+    const missing = [];
+    if (supabaseUrl.length === 0) {
+        missing.push("SALESPROMPTER_SUPABASE_URL or NEXT_PUBLIC_SUPABASE_URL");
+    }
+    if (supabaseServiceRoleKey.length === 0) {
+        missing.push("SUPABASE_SERVICE_ROLE_KEY");
+    }
+    if (missing.length > 0) {
+        throw new Error(`Missing required environment variables for Sales Navigator Supabase export: ${missing.join(", ")}`);
+    }
+    return {
+        supabaseUrl,
+        supabaseServiceRoleKey
+    };
+}
 function normalizeDomainInput(value) {
     return value
         .trim()
@@ -441,6 +461,26 @@ function parseCompanyReference(value) {
         })
     };
 }
+function chunkArray(values, size) {
+    const chunks = [];
+    for (let index = 0; index < values.length; index += size) {
+        chunks.push(values.slice(index, index + size));
+    }
+    return chunks;
+}
+function extractSalesNavContactId(url) {
+    if (!url) {
+        return null;
+    }
+    try {
+        const parsed = new URL(url);
+        const segments = parsed.pathname.split("/").filter((segment) => segment.length > 0);
+        return segments.length > 0 ? segments[segments.length - 1] : null;
+    }
+    catch {
+        return null;
+    }
+}
 function writeWizardLine(message = "") {
     process.stdout.write(`${message}\n`);
 }
@@ -3264,6 +3304,257 @@ program
     }
     printOutput(payload);
 });
+program
+    .command("salesnav:deel-locale-export")
+    .description("Export the Supabase Sales Navigator Deel corpus into German-vs-English outreach backlog files.")
+    .option("--org-id <id>", "Workspace org id. Defaults to the active CLI org.")
+    .option("--limit <number>", "Maximum number of Supabase rows to process", "250000")
+    .option("--page-size <number>", "Supabase page size per request", "1000")
+    .option("--title-filter <mode>", "deel-hr|all", "deel-hr")
+    .requiredOption("--out-dir <path>", "Output directory for summary and locale CSV files")
+    .action(async (options) => {
+    const limit = z.coerce.number().int().min(1).max(500000).parse(options.limit);
+    const pageSize = z.coerce.number().int().min(1).max(1000).parse(options.pageSize);
+    const titleFilter = z.enum(["deel-hr", "all"]).parse(options.titleFilter);
+    let sessionOrgId = null;
+    if (!shouldBypassAuth()) {
+        const session = await requireAuthSession();
+        sessionOrgId = session.user.orgId ?? null;
+    }
+    const orgId = resolveSalesNavigatorHistoricalBackfillOrgId({
+        explicitOrgId: options.orgId,
+        env: process.env,
+        sessionOrgId
+    });
+    const config = resolveSalesNavigatorSupabaseConfig(process.env);
+    const supabase = createClient(config.supabaseUrl, config.supabaseServiceRoleKey, {
+        auth: { persistSession: false }
+    });
+    const countResponse = await supabase
+        .from("linkedin_sales_nav_people")
+        .select("id", { count: "exact", head: true })
+        .eq("org_id", orgId);
+    if (countResponse.error) {
+        throw new Error(`Failed to count linkedin_sales_nav_people rows: ${countResponse.error.message}`);
+    }
+    const totalInOrg = countResponse.count ?? 0;
+    const totalToProcess = Math.min(totalInOrg, limit);
+    const baseSlug = `deel-salesnav-${slugify(orgId) || "workspace"}`;
+    const deCsvPath = path.join(options.outDir, `${baseSlug}-de.csv`);
+    const enCsvPath = path.join(options.outDir, `${baseSlug}-en.csv`);
+    const summaryPath = path.join(options.outDir, `${baseSlug}-summary.json`);
+    const samplesPath = path.join(options.outDir, `${baseSlug}-samples.json`);
+    await mkdir(options.outDir, { recursive: true });
+    await writeFile(deCsvPath, `${buildDeelSalesNavCsvHeader()}\n`, "utf8");
+    await writeFile(enCsvPath, `${buildDeelSalesNavCsvHeader()}\n`, "utf8");
+    const localeCounts = { de: 0, en: 0 };
+    let titleMatchedCount = 0;
+    let titleFilteredOutCount = 0;
+    const fieldCounts = {
+        firstName: 0,
+        lastName: 0,
+        fullName: 0,
+        companyName: 0,
+        companyNameCleaned: 0,
+        preferredProfileUrl: 0,
+        linkedinProfileUrl: 0,
+        companyLinkedInHandle: 0,
+        location: 0,
+        companyLocation: 0,
+        searchQuery: 0
+    };
+    const signalFieldCounts = {
+        location: 0,
+        companyLocation: 0,
+        searchQuery: 0,
+        none: 0
+    };
+    const titleCounts = new Map();
+    const samples = {
+        de: [],
+        en: []
+    };
+    const selectFields = [
+        "id",
+        "org_id",
+        "run_id",
+        "sales_nav_profile_url",
+        "linkedin_profile_url",
+        "default_profile_url",
+        "full_name",
+        "first_name",
+        "last_name",
+        "company_name",
+        "company_url",
+        "regular_company_url",
+        "title",
+        "industry",
+        "location",
+        "company_location",
+        "search_query",
+        "scraped_at"
+    ].join(", ");
+    let processed = 0;
+    let lastSeenId = null;
+    while (processed < totalToProcess) {
+        let query = supabase
+            .from("linkedin_sales_nav_people")
+            .select(selectFields)
+            .eq("org_id", orgId)
+            .order("id", { ascending: true })
+            .limit(Math.min(pageSize, totalToProcess - processed));
+        if (lastSeenId) {
+            query = query.gt("id", lastSeenId);
+        }
+        const response = await query;
+        if (response.error) {
+            throw new Error(`Failed to read linkedin_sales_nav_people rows after ${lastSeenId ?? "start"}: ${response.error.message}`);
+        }
+        const pageRows = (response.data ?? []);
+        if (pageRows.length === 0) {
+            break;
+        }
+        const relevantRows = pageRows.filter((row) => {
+            if (titleFilter === "all") {
+                titleMatchedCount += 1;
+                return true;
+            }
+            const matches = isDeelRelevantSalesNavTitle(row.title);
+            if (matches) {
+                titleMatchedCount += 1;
+                return true;
+            }
+            titleFilteredOutCount += 1;
+            return false;
+        });
+        const preparedRows = relevantRows.map((row) => normalizeDeelSalesNavRow(row));
+        const deRows = preparedRows.filter((row) => row.language === "de");
+        const enRows = preparedRows.filter((row) => row.language === "en");
+        if (deRows.length > 0) {
+            await appendFile(deCsvPath, `${buildDeelSalesNavCsvLines(deRows)}\n`, "utf8");
+        }
+        if (enRows.length > 0) {
+            await appendFile(enCsvPath, `${buildDeelSalesNavCsvLines(enRows)}\n`, "utf8");
+        }
+        for (const row of preparedRows) {
+            localeCounts[row.language] += 1;
+            if (row.signalFields.length === 0) {
+                signalFieldCounts.none += 1;
+            }
+            else {
+                for (const field of row.signalFields) {
+                    if (field === "location") {
+                        signalFieldCounts.location += 1;
+                    }
+                    else if (field === "companyLocation") {
+                        signalFieldCounts.companyLocation += 1;
+                    }
+                    else if (field === "searchQuery") {
+                        signalFieldCounts.searchQuery += 1;
+                    }
+                }
+            }
+            if (row.firstName)
+                fieldCounts.firstName += 1;
+            if (row.lastName)
+                fieldCounts.lastName += 1;
+            if (row.fullName)
+                fieldCounts.fullName += 1;
+            if (row.companyName)
+                fieldCounts.companyName += 1;
+            if (row.companyNameCleaned)
+                fieldCounts.companyNameCleaned += 1;
+            if (row.preferredProfileUrl)
+                fieldCounts.preferredProfileUrl += 1;
+            if (row.linkedinProfileUrl)
+                fieldCounts.linkedinProfileUrl += 1;
+            if (row.companyLinkedInHandle)
+                fieldCounts.companyLinkedInHandle += 1;
+            if (row.location)
+                fieldCounts.location += 1;
+            if (row.companyLocation)
+                fieldCounts.companyLocation += 1;
+            if (row.searchQuery)
+                fieldCounts.searchQuery += 1;
+            if (row.title) {
+                titleCounts.set(row.title, (titleCounts.get(row.title) ?? 0) + 1);
+            }
+            if (samples[row.language].length < 25) {
+                samples[row.language].push(row);
+            }
+        }
+        processed += pageRows.length;
+        lastSeenId = pageRows[pageRows.length - 1]?.id ?? lastSeenId;
+        const completedPages = Math.ceil(processed / pageSize);
+        if (completedPages === 1 || processed === totalToProcess || completedPages % 10 === 0) {
+            writeProgress(`Processed ${processed}/${totalToProcess} Deel Sales Navigator rows for org ${orgId}; kept ${titleMatchedCount} after ${titleFilter} title filtering.`);
+        }
+    }
+    const keptTotal = localeCounts.de + localeCounts.en;
+    const percentage = (count, base = keptTotal) => base > 0 ? Number(((count / base) * 100).toFixed(2)) : 0;
+    const payload = {
+        status: "ok",
+        vendor: "deel",
+        source: "salesnav-supabase",
+        recommendedRouting: "separate-campaigns-by-language",
+        orgId,
+        totalInOrg,
+        scanned: processed,
+        titleFilter,
+        keptAfterTitleFilter: keptTotal,
+        titleMatchedCount,
+        titleFilteredOutCount,
+        truncatedByLimit: totalInOrg > processed,
+        localeCounts,
+        localePercentages: {
+            de: percentage(localeCounts.de),
+            en: percentage(localeCounts.en)
+        },
+        fieldCoverage: {
+            firstName: { count: fieldCounts.firstName, percentage: percentage(fieldCounts.firstName) },
+            lastName: { count: fieldCounts.lastName, percentage: percentage(fieldCounts.lastName) },
+            fullName: { count: fieldCounts.fullName, percentage: percentage(fieldCounts.fullName) },
+            companyName: { count: fieldCounts.companyName, percentage: percentage(fieldCounts.companyName) },
+            companyNameCleaned: {
+                count: fieldCounts.companyNameCleaned,
+                percentage: percentage(fieldCounts.companyNameCleaned)
+            },
+            preferredProfileUrl: {
+                count: fieldCounts.preferredProfileUrl,
+                percentage: percentage(fieldCounts.preferredProfileUrl)
+            },
+            linkedinProfileUrl: {
+                count: fieldCounts.linkedinProfileUrl,
+                percentage: percentage(fieldCounts.linkedinProfileUrl)
+            },
+            companyLinkedInHandle: {
+                count: fieldCounts.companyLinkedInHandle,
+                percentage: percentage(fieldCounts.companyLinkedInHandle)
+            },
+            location: { count: fieldCounts.location, percentage: percentage(fieldCounts.location) },
+            companyLocation: {
+                count: fieldCounts.companyLocation,
+                percentage: percentage(fieldCounts.companyLocation)
+            },
+            searchQuery: { count: fieldCounts.searchQuery, percentage: percentage(fieldCounts.searchQuery) }
+        },
+        signalFieldCounts,
+        topTitles: [...titleCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20),
+        campaignRecommendation: {
+            de: "Only rows with clear DACH signals should enter the German Deel campaign.",
+            en: "Route everything else to a separate English Deel campaign. English is the safer fallback for ambiguous locales."
+        },
+        files: {
+            deCsv: deCsvPath,
+            enCsv: enCsvPath,
+            summary: summaryPath,
+            samples: samplesPath
+        }
+    };
+    await writeJsonFile(summaryPath, payload);
+    await writeJsonFile(samplesPath, samples);
+    printOutput(payload);
+});
 program
     .command("salesnav:crawl")
     .description("Adaptively split broad LinkedIn Sales Navigator people searches into exportable slices and store every finished slice through Salesprompter.")
@@ -3733,6 +4024,94 @@ program
         sqlOut: options.sqlOut ?? null
     });
 });
+program
+    .command("leadlists:deel-outreach:bq")
+    .description("Build Instantly-ready Deel outreach batches from leadPool_new with lead-list provenance, split into German vs English.")
+    .option("--market <market>", "global|europe|dach", "global")
+    .option("--limit <number>", "Max rows to export", "200000")
+    .option("--min-email-score <number>", "Minimum email score to keep", "70")
+    .requiredOption("--out-dir <path>", "Output directory for raw rows, packs, and locale batches")
+    .option("--sql-out <path>", "Optional file path for the generated SQL")
+    .option("--campaign-id <id>", "Fallback Instantly campaign id for all locales")
+    .option("--campaign-id-de <id>", "Instantly campaign id for German/DACH leads")
+    .option("--campaign-id-en <id>", "Instantly campaign id for English/non-DACH leads")
+    .option("--apply", "Create leads in Instantly instead of export-only mode", false)
+    .option("--allow-duplicates", "Do not skip emails already present in the Instantly campaign", false)
+    .action(async (options) => {
+    const market = z.enum(["global", "europe", "dach"]).parse(options.market);
+    const limit = z.coerce.number().int().min(1).max(500000).parse(options.limit);
+    const minEmailScore = z.coerce.number().int().min(0).max(100).parse(options.minEmailScore);
+    const sql = buildDeelOutreachExportSql({ market, limit, minEmailScore });
+    if (options.sqlOut) {
+        await writeTextFile(options.sqlOut, `${sql}\n`);
+    }
+    const rows = await runBigQueryRows(sql, { maxRows: limit });
+    const normalizedRows = normalizeDeelOutreachRows(rows);
+    const pack = buildDeelOutreachPack(market, normalizedRows);
+    const baseSlug = `deel-outreach-${market}`;
+    const rawPath = path.join(options.outDir, `${baseSlug}-raw.json`);
+    const packPath = path.join(options.outDir, `${baseSlug}-pack.json`);
+    const allPath = path.join(options.outDir, `${baseSlug}-all.json`);
+    const dePath = path.join(options.outDir, `${baseSlug}-de.json`);
+    const enPath = path.join(options.outDir, `${baseSlug}-en.json`);
+    await writeJsonFile(rawPath, normalizedRows);
+    await writeJsonFile(packPath, pack);
+    await writeJsonFile(allPath, [...pack.locales.de, ...pack.locales.en]);
+    await writeJsonFile(dePath, pack.locales.de);
+    await writeJsonFile(enPath, pack.locales.en);
+    const syncResults = [];
+    const routes = [
+        {
+            locale: "de",
+            campaignId: options.campaignIdDe ?? options.campaignId,
+            leads: pack.locales.de
+        },
+        {
+            locale: "en",
+            campaignId: options.campaignIdEn ?? options.campaignId,
+            leads: pack.locales.en
+        }
+    ];
+    for (const route of routes) {
+        if (!route.campaignId || route.leads.length === 0) {
+            continue;
+        }
+        const result = await syncProvider.sync("instantly", route.leads, {
+            apply: Boolean(options.apply),
+            instantlyCampaignId: route.campaignId,
+            allowDuplicates: Boolean(options.allowDuplicates)
+        });
+        syncResults.push({
+            locale: route.locale,
+            campaignId: route.campaignId,
+            synced: result.synced,
+            skipped: result.skipped ?? 0,
+            dryRun: result.dryRun,
+            provider: result.provider ?? "instantly"
+        });
+    }
+    printOutput({
+        status: "ok",
+        vendor: "deel",
+        market,
+        limit,
+        minEmailScore,
+        rowCount: normalizedRows.length,
+        hitLimit: normalizedRows.length === limit,
+        localeCounts: pack.summary.localeCounts,
+        segmentCounts: pack.summary.segmentCounts,
+        averageEmailScoreByLocale: pack.summary.averageEmailScoreByLocale,
+        recommendedRouting: "separate-campaigns-by-language",
+        outDir: options.outDir,
+        raw: rawPath,
+        pack: packPath,
+        all: allPath,
+        german: dePath,
+        english: enPath,
+        syncResults,
+        sqlOut: options.sqlOut ?? null
+    });
+});
 program
     .command("leadlists:funnel:bq")
     .description("Build an upstream lead-list funnel report for a vendor/market.")