chore: import upstream snapshot with attribution

apps/sim/enrichments/company-info/company-info.test.ts

@@ -0,0 +1,67 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { companyInfoEnrichment } from '@/enrichments/company-info/company-info'
+import type { EnrichmentProvider } from '@/enrichments/types'
+
+function provider(id: string): EnrichmentProvider {
+  const p = companyInfoEnrichment.providers.find((x) => x.id === id)
+  if (!p) throw new Error(`Provider ${id} not found in company-info cascade`)
+  return p
+}
+
+const domainInput = { domain: 'https://www.acme.com/about' }
+
+describe('company-info enrichment cascade', () => {
+  it('chains the company-info providers in waterfall order', () => {
+    expect(companyInfoEnrichment.providers.map((p) => p.id)).toEqual([
+      'hunter',
+      'pdl',
+      'datagma',
+      'leadmagic',
+    ])
+  })
+
+  describe('hunter', () => {
+    const p = provider('hunter')
+    it('normalizes the domain and maps size/description', () => {
+      expect(p.toolId).toBe('hunter_companies_find')
+      expect(p.buildParams(domainInput)).toEqual({ domain: 'acme.com' })
+      expect(p.buildParams({ domain: '' })).toBeNull()
+      expect(p.mapOutput({ size: '11-50', description: 'Payments' })).toEqual({
+        employeeCount: '11-50',
+        description: 'Payments',
+      })
+      expect(p.mapOutput({})).toEqual({})
+    })
+  })
+
+  describe('datagma', () => {
+    const p = provider('datagma')
+    it('passes the normalized domain as data and maps companySize/shortDescription', () => {
+      expect(p.toolId).toBe('datagma_enrich_company')
+      expect(p.buildParams(domainInput)).toEqual({ data: 'acme.com' })
+      expect(p.buildParams({ domain: '' })).toBeNull()
+      expect(p.mapOutput({ companySize: '11-50', shortDescription: 'Payments' })).toEqual({
+        employeeCount: '11-50',
+        description: 'Payments',
+      })
+      expect(p.mapOutput({})).toEqual({})
+    })
+  })
+
+  describe('leadmagic', () => {
+    const p = provider('leadmagic')
+    it('searches by domain and prefers the headcount range', () => {
+      expect(p.toolId).toBe('leadmagic_company_search')
+      expect(p.buildParams(domainInput)).toEqual({ company_domain: 'acme.com' })
+      expect(p.buildParams({ domain: '' })).toBeNull()
+      expect(
+        p.mapOutput({ employeeRange: '11-50', employeeCount: 42, description: 'Pay' })
+      ).toEqual({ employeeCount: '11-50', description: 'Pay' })
+      expect(p.mapOutput({ employeeCount: 42 })).toEqual({ employeeCount: '42' })
+      expect(p.mapOutput({})).toEqual({})
+    })
+  })
+})

apps/sim/enrichments/company-info/company-info.ts

@@ -0,0 +1,94 @@
+import { filterUndefined } from '@sim/utils/object'
+import { Building2 } from 'lucide-react'
+import { normalizeDomain, str, toolProvider } from '@/enrichments/providers'
+import type { EnrichmentConfig } from '@/enrichments/types'
+
+/**
+ * Company Info enrichment. Looks up a company by domain, trying Hunter first
+ * (free) then People Data Labs, then Datagma and LeadMagic as fallbacks. Outputs
+ * are limited to the fields the providers reliably return — employee count and
+ * description — so the result stays consistent regardless of which provider fills
+ * the cell. `employeeCount` is a string so Hunter's range bucket (e.g. `"11-50"`),
+ * PDL's exact count, and LeadMagic's range all map onto the same column.
+ */
+export const companyInfoEnrichment: EnrichmentConfig = {
+  id: 'company-info',
+  name: 'Company Info',
+  description: "Look up a company's size and description from its domain.",
+  icon: Building2,
+  inputs: [{ id: 'domain', name: 'Company domain', type: 'string', required: true }],
+  outputs: [
+    { id: 'employeeCount', name: 'employee count', type: 'string' },
+    { id: 'description', name: 'description', type: 'string' },
+  ],
+  providers: [
+    toolProvider({
+      id: 'hunter',
+      label: 'Hunter',
+      toolId: 'hunter_companies_find',
+      buildParams: (inputs) => {
+        const domain = normalizeDomain(inputs.domain)
+        if (!domain) return null
+        return { domain }
+      },
+      mapOutput: (output) => {
+        return filterUndefined({
+          employeeCount: str(output.size) || undefined,
+          description: str(output.description) || undefined,
+        })
+      },
+    }),
+    toolProvider({
+      id: 'pdl',
+      label: 'People Data Labs',
+      toolId: 'pdl_company_enrich',
+      buildParams: (inputs) => {
+        const website = normalizeDomain(inputs.domain)
+        if (!website) return null
+        // `required` makes PDL 404 (free) when neither field we extract is
+        // present, instead of charging a credit for a match we'd discard.
+        return { website, required: 'employee_count OR summary' }
+      },
+      mapOutput: (output) => {
+        const company = output.company as Record<string, unknown> | undefined
+        return filterUndefined({
+          employeeCount: str(company?.employee_count) || undefined,
+          description: str(company?.summary) || undefined,
+        })
+      },
+    }),
+    toolProvider({
+      id: 'datagma',
+      label: 'Datagma',
+      toolId: 'datagma_enrich_company',
+      buildParams: (inputs) => {
+        const data = normalizeDomain(inputs.domain)
+        if (!data) return null
+        return { data }
+      },
+      mapOutput: (output) => {
+        return filterUndefined({
+          employeeCount: str(output.companySize) || undefined,
+          description: str(output.shortDescription) || undefined,
+        })
+      },
+    }),
+    toolProvider({
+      id: 'leadmagic',
+      label: 'LeadMagic',
+      toolId: 'leadmagic_company_search',
+      buildParams: (inputs) => {
+        const companyDomain = normalizeDomain(inputs.domain)
+        if (!companyDomain) return null
+        return { company_domain: companyDomain }
+      },
+      mapOutput: (output) => {
+        // Prefer the headcount range to match Hunter's bucket style; fall back to the exact count.
+        return filterUndefined({
+          employeeCount: str(output.employeeRange) || str(output.employeeCount) || undefined,
+          description: str(output.description) || undefined,
+        })
+      },
+    }),
+  ],
+}

apps/sim/enrichments/company-info/index.ts

@@ -0,0 +1 @@
+export { companyInfoEnrichment } from './company-info'