@coldiq/mcp 0.3.9 → 0.3.10

package/tests/tools/search-companies.test.ts

@@ -13,7 +13,7 @@ describe('search_companies handler', () => {
     globalThis.fetch = originalFetch
   })
 
-  it('returns results from first successful provider', async () => {
+  it('returns results from first successful provider (compact by default)', async () => {
     globalThis.fetch = vi.fn(async () =>
       new Response(JSON.stringify({ data: [{ name: 'ColdIQ', domain: 'coldiq.com' }] }), { status: 200 })
     ) as typeof fetch
@@ -23,7 +23,83 @@ describe('search_companies handler', () => {
     expect(result.isError).toBeUndefined()
     const parsed = JSON.parse(result.content[0].text)
     expect(parsed._meta.provider).toBe('companyenrich')
-    expect(parsed.data.data).toHaveLength(1)
+    // Compact-by-default: the raw provider array is normalized into companies[].
+    expect(parsed.data.companies).toHaveLength(1)
+    expect(parsed.data.companies[0]).toMatchObject({ name: 'ColdIQ', domain: 'coldiq.com' })
+  })
+
+  it('compact (default) keeps identity + firmographic fields and drops heavy ones', async () => {
+    // Mirror the real CompanyEnrich shape: companies under data.items[], each a
+    // heavy object with funding/technologies/keywords/socials/seo.
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({
+        items: [{
+          id: '0192562e-7008-702b-97a2-0b2c489d339b',
+          name: 'Hugging Face',
+          domain: 'huggingface.co',
+          website: 'https://huggingface.co',
+          industry: 'Business Services',
+          categories: ['b2b', 'b2c', 'saas'],
+          employees: '201-500',
+          revenue: '10m-50m',
+          founded_year: 2016,
+          description: 'A very long company description that should be dropped in compact mode...',
+          keywords: Array.from({ length: 28 }, (_, i) => `kw${i}`),
+          technologies: ['Stripe', 'Nginx', 'Node-Js'],
+          naics_codes: ['511210', '518210'],
+          socials: { linkedin_url: 'https://www.linkedin.com/company/huggingface', twitter_url: 'https://twitter.com/huggingface' },
+          financial: { total_funding: 395200000, funding: [{ date: '2024-08-01', type: 'Venture Round' }] },
+          location: { country: { code: 'FR', name: 'France' }, city: { name: 'Paris' } },
+        }],
+        page: 1,
+        totalItems: 10000,
+      }), { status: 200 })
+    ) as typeof fetch
+
+    const result = await searchCompaniesHandler({ keywords: ['SaaS'], countries: ['FR'], limit: 5 })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.data.total).toBe(10000)
+    expect(parsed.data.companies).toHaveLength(1)
+    const c = parsed.data.companies[0]
+    // Kept: identity + firmographics + downstream-critical linkedin_url.
+    expect(c).toEqual({
+      name: 'Hugging Face',
+      domain: 'huggingface.co',
+      website: 'https://huggingface.co',
+      linkedin_url: 'https://www.linkedin.com/company/huggingface',
+      employees: '201-500',
+      revenue: '10m-50m',
+      industry: 'Business Services',
+      country: 'France',
+      city: 'Paris',
+      founded_year: 2016,
+      categories: ['b2b', 'b2c', 'saas'],
+    })
+    // Dropped heavy fields.
+    expect(c.description).toBeUndefined()
+    expect(c.keywords).toBeUndefined()
+    expect(c.technologies).toBeUndefined()
+    expect(c.naics_codes).toBeUndefined()
+    expect(c.financial).toBeUndefined()
+    expect(c.id).toBeUndefined()
+  })
+
+  it('fields=verbose returns the raw provider passthrough unchanged', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ items: [{ name: 'Hugging Face', keywords: ['ai'], technologies: ['Stripe'] }], totalItems: 10000 }), { status: 200 })
+    ) as typeof fetch
+
+    const result = await searchCompaniesHandler({ keywords: ['SaaS'], limit: 5, fields: 'verbose' })
+
+    expect(result.isError).toBeUndefined()
+    const parsed = JSON.parse(result.content[0].text)
+    // Raw shape preserved: items[] with heavy fields, no companies[] normalization.
+    expect(parsed.data.items).toHaveLength(1)
+    expect(parsed.data.items[0].keywords).toEqual(['ai'])
+    expect(parsed.data.items[0].technologies).toEqual(['Stripe'])
+    expect(parsed.data.companies).toBeUndefined()
   })
 
   it('falls back to FullEnrich (priority 2) on CompanyEnrich failure', async () => {

package/tests/utils/compact-companies.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest'
+import {
+  compactCompaniesPayload,
+  extractCompaniesArray,
+  normalizeCompany,
+} from '../../src/utils/compact-companies.js'
+
+describe('extractCompaniesArray', () => {
+  it('finds the array under each provider key', () => {
+    expect(extractCompaniesArray({ items: [{ name: 'A' }] })).toHaveLength(1) // CompanyEnrich
+    expect(extractCompaniesArray({ companies: [{ name: 'A' }] })).toHaveLength(1) // FullEnrich
+    expect(extractCompaniesArray({ organizations: [{ name: 'A' }, { name: 'B' }] })).toHaveLength(2) // Apollo
+    expect(extractCompaniesArray({ data: [{ name: 'A' }] })).toHaveLength(1) // generic
+    expect(extractCompaniesArray({ results: [{ name: 'A' }] })).toHaveLength(1)
+  })
+
+  it('handles a bare top-level array', () => {
+    expect(extractCompaniesArray([{ name: 'A' }])).toHaveLength(1)
+  })
+
+  it('finds AI-Ark content[] and LinkUp nested data.companies[]', () => {
+    // AI-Ark companies live under content[] (registry hasResult: isNonEmptyArray(d.content)).
+    expect(extractCompaniesArray({ content: [{ name: 'A' }, { name: 'B' }] })).toHaveLength(2)
+    // LinkUp (search/fundraising/hiring) nests under data.companies[]
+    // (registry hasResult: isNonEmptyArray(d.data.companies)).
+    expect(extractCompaniesArray({ data: { companies: [{ name: 'A' }] } })).toHaveLength(1)
+    expect(extractCompaniesArray({ data: { organizations: [{ name: 'A' }, { name: 'B' }] } })).toHaveLength(2)
+  })
+
+  it('prefers a direct array under data over descending into a nested object', () => {
+    // PDL/Prospeo/TheirStack shape: { data: [...] } must stay flat, not be skipped.
+    expect(extractCompaniesArray({ data: [{ name: 'A' }] })).toHaveLength(1)
+  })
+
+  it('returns [] for null / non-object / no recognized key', () => {
+    expect(extractCompaniesArray(null)).toEqual([])
+    expect(extractCompaniesArray('nope')).toEqual([])
+    expect(extractCompaniesArray({ totalItems: 10 })).toEqual([])
+  })
+})
+
+describe('normalizeCompany', () => {
+  it('maps the CompanyEnrich nested shape to compact fields', () => {
+    const c = normalizeCompany({
+      id: 'uuid-123',
+      name: 'Mistral AI',
+      domain: 'mistral.ai',
+      website: 'https://mistral.ai',
+      industry: 'Software',
+      categories: ['b2b', 'saas'],
+      employees: '201-500',
+      revenue: '1m-10m',
+      founded_year: 2023,
+      description: 'long blurb',
+      keywords: ['a', 'b'],
+      technologies: ['Gmail'],
+      socials: { linkedin_url: 'https://www.linkedin.com/company/mistralai' },
+      location: { country: { code: 'FR', name: 'France' }, city: { name: 'Paris' } },
+    })
+    expect(c).toEqual({
+      name: 'Mistral AI',
+      domain: 'mistral.ai',
+      website: 'https://mistral.ai',
+      linkedin_url: 'https://www.linkedin.com/company/mistralai',
+      employees: '201-500',
+      revenue: '1m-10m',
+      industry: 'Software',
+      country: 'France',
+      city: 'Paris',
+      founded_year: 2023,
+      categories: ['b2b', 'saas'],
+    })
+  })
+
+  it('maps the Apollo organization shape (numeric employees, flat fields)', () => {
+    const c = normalizeCompany({
+      name: 'Apple',
+      primary_domain: 'apple.com',
+      website_url: 'https://apple.com',
+      linkedin_url: 'https://www.linkedin.com/company/apple',
+      estimated_num_employees: 164000,
+      industry: 'consumer electronics',
+      founded_year: 1976,
+    })
+    expect(c).toMatchObject({
+      name: 'Apple',
+      domain: 'apple.com',
+      website: 'https://apple.com',
+      linkedin_url: 'https://www.linkedin.com/company/apple',
+      employees: 164000,
+      industry: 'consumer electronics',
+      founded_year: 1976,
+    })
+  })
+
+  it('maps BlitzAPI employees_on_linkedin into employees', () => {
+    const c = normalizeCompany({ name: 'Blitz Co', domain: 'blitz.co', employees_on_linkedin: 320 })
+    expect(c).toMatchObject({ name: 'Blitz Co', domain: 'blitz.co', employees: 320 })
+  })
+
+  it('rejects a non-LinkedIn url in the linkedin slot', () => {
+    const c = normalizeCompany({ name: 'X', socials: { linkedin_url: 'https://twitter.com/x' } })
+    expect(c?.linkedin_url).toBeUndefined()
+    expect(c?.name).toBe('X')
+  })
+
+  it('returns null for empty / non-object records', () => {
+    expect(normalizeCompany(null)).toBeNull()
+    expect(normalizeCompany({})).toBeNull()
+    expect(normalizeCompany([{ name: 'A' }])).toBeNull()
+    expect(normalizeCompany('x')).toBeNull()
+  })
+
+  it('omits fields that are not present', () => {
+    const c = normalizeCompany({ name: 'Solo' })
+    expect(c).toEqual({ name: 'Solo' })
+  })
+})
+
+describe('compactCompaniesPayload', () => {
+  it('normalizes items[] and surfaces totalItems', () => {
+    const out = compactCompaniesPayload({
+      items: [{ name: 'A', domain: 'a.com' }, { name: 'B', domain: 'b.com' }],
+      totalItems: 10000,
+    })
+    expect(out.companies).toHaveLength(2)
+    expect(out.total).toBe(10000)
+  })
+
+  it('reads Apollo pagination.total_entries as total', () => {
+    const out = compactCompaniesPayload({ organizations: [{ name: 'A' }], pagination: { total_entries: 8371 } })
+    expect(out.companies).toHaveLength(1)
+    expect(out.total).toBe(8371)
+  })
+
+  it('drops records that normalize to nothing but keeps real ones', () => {
+    const out = compactCompaniesPayload({ items: [{ name: 'A' }, {}, { foo: 'bar' }] })
+    expect(out.companies).toHaveLength(1)
+    expect(out.companies[0].name).toBe('A')
+  })
+
+  it('returns an empty companies array (no total) when there is nothing to extract', () => {
+    const out = compactCompaniesPayload({ unexpected: true })
+    expect(out).toEqual({ companies: [] })
+  })
+})