@coldiq/mcp 0.1.0

package/tests/registry-linkupapi.test.ts

@@ -0,0 +1,331 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+describe('linkupapi providers — search_companies', () => {
+  const providers = getProviders('search_companies')
+  const search = providers.find((p) => p.id === 'linkupapi-search')!
+  const fundraising = providers.find((p) => p.id === 'linkupapi-fundraising')!
+  const hiring = providers.find((p) => p.id === 'linkupapi-hiring')!
+
+  it('all three providers are registered', () => {
+    expect(search).toBeDefined()
+    expect(fundraising).toBeDefined()
+    expect(hiring).toBeDefined()
+  })
+
+  it('priorities are 14, 15, 16 in order', () => {
+    expect(search.priority).toBe(14)
+    expect(fundraising.priority).toBe(15)
+    expect(hiring.priority).toBe(16)
+  })
+
+  describe('linkupapi-search', () => {
+    it('maps keywords, industries, locations, employee range', () => {
+      const result = search.mapParams({
+        keywords: ['AI', 'SaaS'],
+        industries: ['Software'],
+        locations: ['San Francisco'],
+        min_employees: 51,
+        max_employees: 200,
+        limit: 10,
+      })
+      expect((result.body as Record<string, unknown>).keyword).toBe('AI SaaS')
+      expect((result.body as Record<string, unknown>).employee_range).toBe('51-200')
+      expect((result.body as Record<string, unknown>).total_results).toBe(10)
+    })
+
+    it('caps total_results at 25', () => {
+      const result = search.mapParams({ limit: 100 })
+      expect((result.body as Record<string, unknown>).total_results).toBe(25)
+    })
+
+    it('hasResult: true for non-empty companies', () => {
+      expect(search.hasResult({ data: { companies: [{ name: 'Acme' }] } })).toBe(true)
+    })
+
+    it('hasResult: false for empty companies', () => {
+      expect(search.hasResult({ data: { companies: [] } })).toBe(false)
+      expect(search.hasResult({})).toBe(false)
+    })
+  })
+
+  describe('linkupapi-fundraising', () => {
+    it('is not applicable without funding filter', () => {
+      expect(fundraising.isApplicable!({ keywords: ['AI'] })).toBe(false)
+    })
+
+    it('is not applicable with funding filter but no text', () => {
+      expect(fundraising.isApplicable!({ funding_stages: ['series_b'] })).toBe(false)
+    })
+
+    it('is applicable with funding_stages + keywords', () => {
+      expect(fundraising.isApplicable!({ funding_stages: ['series_b'], keywords: ['SaaS'] })).toBe(true)
+    })
+
+    it('is applicable with min_funding_amount + industries', () => {
+      expect(fundraising.isApplicable!({ min_funding_amount: 1_000_000, industries: ['Software'] })).toBe(true)
+    })
+
+    it('is applicable with min_funding_year + keywords', () => {
+      expect(fundraising.isApplicable!({ min_funding_year: 2023, keywords: ['fintech'] })).toBe(true)
+    })
+
+    it('maps funding_stage correctly: series_b → Series B', () => {
+      const result = fundraising.mapParams({
+        funding_stages: ['series_b'],
+        keywords: ['SaaS'],
+        industries: ['Software'],
+      })
+      expect((result.body as Record<string, unknown>).funding_stage).toBe('Series B')
+    })
+
+    it('maps funding_stage: series_d → Series D+', () => {
+      const result = fundraising.mapParams({ funding_stages: ['series_d'], keywords: ['tech'], industries: [] })
+      expect((result.body as Record<string, unknown>).funding_stage).toBe('Series D+')
+    })
+
+    it('maps seed correctly', () => {
+      const result = fundraising.mapParams({ funding_stages: ['seed'], keywords: ['AI'], industries: [] })
+      expect((result.body as Record<string, unknown>).funding_stage).toBe('Seed')
+    })
+
+    it('builds keyword from keywords + industries', () => {
+      const result = fundraising.mapParams({
+        funding_stages: ['series_a'],
+        keywords: ['AI'],
+        industries: ['Software'],
+      })
+      expect((result.body as Record<string, unknown>).keyword).toBe('AI Software')
+    })
+
+    it('hasResult: true for non-empty companies', () => {
+      expect(fundraising.hasResult({ data: { companies: [{}] } })).toBe(true)
+    })
+
+    it('hasResult: false for empty or missing companies', () => {
+      expect(fundraising.hasResult({ data: { companies: [] } })).toBe(false)
+      expect(fundraising.hasResult({})).toBe(false)
+    })
+  })
+
+  describe('linkupapi-hiring', () => {
+    it('is only applicable when is_hiring is true', () => {
+      expect(hiring.isApplicable!({ is_hiring: true })).toBe(true)
+      expect(hiring.isApplicable!({ is_hiring: false })).toBe(false)
+      expect(hiring.isApplicable!({})).toBe(false)
+    })
+
+    it('maps industry, location, employee range', () => {
+      const result = hiring.mapParams({
+        is_hiring: true,
+        industries: ['SaaS'],
+        locations: ['New York'],
+        min_employees: 51,
+        max_employees: 200,
+        limit: 10,
+      })
+      const body = result.body as Record<string, unknown>
+      expect(body.industry).toBe('SaaS')
+      expect(body.location).toBe('New York')
+      expect(body.employee_range).toBe('51-200')
+    })
+
+    it('hasResult: true for non-empty companies', () => {
+      expect(hiring.hasResult({ data: { companies: [{}] } })).toBe(true)
+    })
+  })
+})
+
+describe('linkupapi provider — find_people', () => {
+  const providers = getProviders('find_people')
+  const sp = providers.find((p) => p.id === 'linkupapi-search-profiles')!
+
+  it('is registered at priority 5', () => {
+    expect(sp).toBeDefined()
+    expect(sp.priority).toBe(5)
+  })
+
+  it('isApplicable: false when company_domains present', () => {
+    expect(sp.isApplicable!({ company_domains: ['stripe.com'] })).toBe(false)
+  })
+
+  it('isApplicable: false when company_linkedin_urls present', () => {
+    expect(sp.isApplicable!({ company_linkedin_urls: ['https://linkedin.com/company/stripe'] })).toBe(false)
+  })
+
+  it('isApplicable: true when only title/keyword/location filters', () => {
+    expect(sp.isApplicable!({ job_titles: ['CEO'], locations: ['Paris'] })).toBe(true)
+    expect(sp.isApplicable!({})).toBe(true)
+  })
+
+  it('maps job_titles, locations, keywords', () => {
+    const result = sp.mapParams({ job_titles: ['VP Sales'], locations: ['US'], keywords: ['fintech'], limit: 20 })
+    const body = result.body as Record<string, unknown>
+    expect(body.job_title).toEqual(['VP Sales'])
+    expect(body.location).toEqual(['US'])
+    expect(body.keyword).toBe('fintech')
+    expect(body.total_results).toBe(20)
+  })
+
+  it('hasResult: true for non-empty profiles', () => {
+    expect(sp.hasResult({ data: { profiles: [{}] } })).toBe(true)
+  })
+
+  it('hasResult: false for empty profiles', () => {
+    expect(sp.hasResult({ data: { profiles: [] } })).toBe(false)
+    expect(sp.hasResult({})).toBe(false)
+  })
+})
+
+describe('linkupapi provider — verify_email', () => {
+  const providers = getProviders('verify_email')
+  const lv = providers.find((p) => p.id === 'linkupapi-validate')!
+
+  it('is registered at priority 4', () => {
+    expect(lv).toBeDefined()
+    expect(lv.priority).toBe(4)
+  })
+
+  it('maps email', () => {
+    const result = lv.mapParams({ email: 'michel@coldiq.com' })
+    expect((result.body as Record<string, unknown>).email).toBe('michel@coldiq.com')
+  })
+
+  it('hasResult: true when status present', () => {
+    expect(lv.hasResult({ status: 'valid' })).toBe(true)
+  })
+
+  it('hasResult: true when verified present', () => {
+    expect(lv.hasResult({ verified: true })).toBe(true)
+  })
+
+  it('hasResult: false for empty object', () => {
+    expect(lv.hasResult({})).toBe(false)
+  })
+})
+
+describe('linkupapi providers — enrich_company', () => {
+  const providers = getProviders('enrich_company')
+  const byDomain = providers.find((p) => p.id === 'linkupapi-by-domain')!
+  const byUrl = providers.find((p) => p.id === 'linkupapi-by-url')!
+
+  it('both providers registered', () => {
+    expect(byDomain).toBeDefined()
+    expect(byUrl).toBeDefined()
+  })
+
+  it('priorities are 13 and 14', () => {
+    expect(byDomain.priority).toBe(13)
+    expect(byUrl.priority).toBe(14)
+  })
+
+  it('linkupapi-by-domain: applicable only when domain present', () => {
+    expect(byDomain.isApplicable!({ domain: 'coldiq.com' })).toBe(true)
+    expect(byDomain.isApplicable!({})).toBe(false)
+  })
+
+  it('linkupapi-by-domain: maps domain', () => {
+    const result = byDomain.mapParams({ domain: 'coldiq.com' })
+    expect((result.body as Record<string, unknown>).domain).toBe('coldiq.com')
+  })
+
+  it('linkupapi-by-url: applicable only when linkedin_url present', () => {
+    expect(byUrl.isApplicable!({ linkedin_url: 'https://linkedin.com/company/coldiq' })).toBe(true)
+    expect(byUrl.isApplicable!({})).toBe(false)
+  })
+
+  it('linkupapi-by-url: maps linkedin_url as company_url', () => {
+    const result = byUrl.mapParams({ linkedin_url: 'https://linkedin.com/company/coldiq' })
+    expect((result.body as Record<string, unknown>).company_url).toBe('https://linkedin.com/company/coldiq')
+  })
+
+  it('hasResult: true when name present', () => {
+    expect(byDomain.hasResult({ name: 'ColdIQ' })).toBe(true)
+    expect(byUrl.hasResult({ domain: 'coldiq.com' })).toBe(true)
+  })
+})
+
+describe('linkupapi providers — enrich_person', () => {
+  const providers = getProviders('enrich_person')
+  const profileEnrich = providers.find((p) => p.id === 'linkupapi-profile-enrich')!
+  const emailReverse = providers.find((p) => p.id === 'linkupapi-email-reverse')!
+
+  it('both providers registered', () => {
+    expect(profileEnrich).toBeDefined()
+    expect(emailReverse).toBeDefined()
+  })
+
+  it('priorities are 1 and 2', () => {
+    expect(profileEnrich.priority).toBe(1)
+    expect(emailReverse.priority).toBe(2)
+  })
+
+  describe('linkupapi-profile-enrich', () => {
+    it('is applicable with first+last+company', () => {
+      expect(profileEnrich.isApplicable!({ first_name: 'Michel', last_name: 'Lieben', company_name: 'ColdIQ' })).toBe(true)
+    })
+
+    it('is applicable with first+last+domain', () => {
+      expect(profileEnrich.isApplicable!({ first_name: 'Michel', last_name: 'Lieben', domain: 'coldiq.com' })).toBe(true)
+    })
+
+    it('is not applicable without company or domain', () => {
+      expect(profileEnrich.isApplicable!({ first_name: 'Michel', last_name: 'Lieben' })).toBe(false)
+    })
+
+    it('is not applicable without last_name', () => {
+      expect(profileEnrich.isApplicable!({ first_name: 'Michel', company_name: 'ColdIQ' })).toBe(false)
+    })
+
+    it('maps company_name from domain when company_name absent', () => {
+      const result = profileEnrich.mapParams({ first_name: 'Michel', last_name: 'Lieben', domain: 'coldiq.com' })
+      expect((result.body as Record<string, unknown>).company_name).toBe('coldiq.com')
+    })
+
+    it('prefers company_name over domain', () => {
+      const result = profileEnrich.mapParams({
+        first_name: 'Michel',
+        last_name: 'Lieben',
+        company_name: 'ColdIQ',
+        domain: 'coldiq.com',
+      })
+      expect((result.body as Record<string, unknown>).company_name).toBe('ColdIQ')
+    })
+
+    it('hasResult: true for { status: success, data: {...} }', () => {
+      expect(profileEnrich.hasResult({ status: 'success', data: { full_profile_data: { first_name: 'Michel' } } })).toBe(true)
+    })
+
+    it('hasResult: false when status is not success', () => {
+      expect(profileEnrich.hasResult({ status: 'error' })).toBe(false)
+    })
+
+    it('hasResult: false for empty object', () => {
+      expect(profileEnrich.hasResult({})).toBe(false)
+    })
+  })
+
+  describe('linkupapi-email-reverse', () => {
+    it('is applicable with valid email', () => {
+      expect(emailReverse.isApplicable!({ email: 'michel@coldiq.com' })).toBe(true)
+    })
+
+    it('is not applicable without email', () => {
+      expect(emailReverse.isApplicable!({})).toBe(false)
+      expect(emailReverse.isApplicable!({ email: 'notanemail' })).toBe(false)
+    })
+
+    it('maps email', () => {
+      const result = emailReverse.mapParams({ email: 'michel@coldiq.com' })
+      expect((result.body as Record<string, unknown>).email).toBe('michel@coldiq.com')
+    })
+
+    it('hasResult: true for { status: success, data: {...} }', () => {
+      expect(emailReverse.hasResult({ status: 'success', data: { person_found: { first_name: 'Michel' } } })).toBe(true)
+    })
+
+    it('hasResult: false for empty object', () => {
+      expect(emailReverse.hasResult({})).toBe(false)
+    })
+  })
+})

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

@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+const providers = () => getProviders('search_companies')
+const get = (id: string) => {
+  const p = providers().find((p) => p.id === id)
+  if (!p) throw new Error(`Provider '${id}' not found in search_companies`)
+  return p
+}
+
+// ---------------------------------------------------------------------------
+// prospeo-search-company
+// ---------------------------------------------------------------------------
+
+describe('prospeo-search-company', () => {
+  const p = () => get('prospeo-search-company')
+
+  it('isApplicable: true with keywords', () => {
+    expect(p().isApplicable!({ keywords: ['cold email'] })).toBe(true)
+  })
+
+  it('isApplicable: true with industries', () => {
+    expect(p().isApplicable!({ industries: ['SaaS'] })).toBe(true)
+  })
+
+  it('isApplicable: true with countries', () => {
+    expect(p().isApplicable!({ countries: ['BE'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(false)
+  })
+
+  it('mapParams builds Prospeo filter shape', () => {
+    expect(p().mapParams({
+      keywords: ['sales engagement'],
+      industries: ['SaaS'],
+      countries: ['BE'],
+      min_employees: 10,
+      max_employees: 200,
+    })).toEqual({
+      body: {
+        filters: {
+          company_keywords: { include: ['sales engagement'] },
+          company_industry: { include: ['SaaS'] },
+          company_country: { include: ['Belgium'] },
+          company_headcount_custom: { min: 10, max: 200 },
+        },
+      },
+    })
+  })
+
+  it('mapParams omits absent filter keys', () => {
+    const result = p().mapParams({ keywords: ['outbound'] })
+    const filters = (result.body as Record<string, unknown>).filters as Record<string, unknown>
+    expect(filters.company_industry).toBeUndefined()
+    expect(filters.company_country).toBeUndefined()
+    expect(filters.company_headcount_custom).toBeUndefined()
+  })
+
+  it('mapParams includes headcount when only min is given', () => {
+    const result = p().mapParams({ keywords: ['crm'], min_employees: 50 })
+    const filters = (result.body as Record<string, unknown>).filters as Record<string, unknown>
+    expect(filters.company_headcount_custom).toEqual({ min: 50, max: undefined })
+  })
+
+  it('hasResult: true when data array non-empty', () => {
+    expect(p().hasResult({ data: [{ name: 'ColdIQ' }] })).toBe(true)
+  })
+
+  it('hasResult: false when data is empty', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 17', () => {
+    expect(p().priority).toBe(17)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ai-ark-companies
+// ---------------------------------------------------------------------------
+
+describe('ai-ark-companies', () => {
+  const p = () => get('ai-ark-companies')
+
+  it('isApplicable: true with keywords', () => {
+    expect(p().isApplicable!({ keywords: ['cold email'] })).toBe(true)
+  })
+
+  it('isApplicable: true with industries', () => {
+    expect(p().isApplicable!({ industries: ['SaaS'] })).toBe(true)
+  })
+
+  it('isApplicable: true with countries', () => {
+    expect(p().isApplicable!({ countries: ['BE'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only min_employees', () => {
+    expect(p().isApplicable!({ min_employees: 50 })).toBe(false)
+  })
+
+  it('mapParams builds AI-Ark account/contact shape', () => {
+    const result = p().mapParams({
+      keywords: ['outbound sales'],
+      industries: ['SaaS'],
+      countries: ['BE'],
+      min_employees: 10,
+      max_employees: 500,
+      funding_stages: ['Series A'],
+      limit: 20,
+    })
+    expect(result).toEqual({
+      body: {
+        account: {
+          industries: { any: { include: ['SaaS'] } },
+          location: { any: { include: ['Belgium'] } },
+          employeeSize: {
+            type: 'RANGE',
+            range: [{ start: 10, end: 500 }],
+          },
+          funding: { stage: { include: ['Series A'] } },
+        },
+        contact: {
+          keywordsInProfile: { any: { include: ['outbound sales'] } },
+        },
+        size: 20,
+      },
+    })
+  })
+
+  it('mapParams omits absent account keys', () => {
+    const result = p().mapParams({ keywords: ['CRM'] })
+    const account = (result.body as Record<string, unknown>).account as Record<string, unknown>
+    expect(account.industries).toBeUndefined()
+    expect(account.location).toBeUndefined()
+    expect(account.employeeSize).toBeUndefined()
+    expect(account.funding).toBeUndefined()
+  })
+
+  it('mapParams omits contact when no keywords', () => {
+    const result = p().mapParams({ industries: ['SaaS'] })
+    expect((result.body as Record<string, unknown>).contact).toBeUndefined()
+  })
+
+  it('mapParams caps size at 100', () => {
+    const result = p().mapParams({ keywords: ['sales'], limit: 999 })
+    expect((result.body as Record<string, unknown>).size).toBe(100)
+  })
+
+  it('hasResult: true when content array non-empty', () => {
+    expect(p().hasResult({ content: [{ name: 'ColdIQ' }] })).toBe(true)
+  })
+
+  it('hasResult: false when content is empty', () => {
+    expect(p().hasResult({ content: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 18', () => {
+    expect(p().priority).toBe(18)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Ordering: search_companies providers sorted correctly
+// ---------------------------------------------------------------------------
+
+describe('search_companies priority ordering', () => {
+  it('all providers are sorted by priority', () => {
+    const ps = providers()
+    for (let i = 1; i < ps.length; i++) {
+      expect(ps[i].priority).toBeGreaterThanOrEqual(ps[i - 1].priority)
+    }
+  })
+
+  it('ai-ark-companies is last (priority 18)', () => {
+    const ps = providers()
+    expect(ps[ps.length - 1].id).toBe('ai-ark-companies')
+  })
+})

package/tests/registry-search-jobs.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+const providers = () => getProviders('search_jobs')
+const get = (id: string) => {
+  const p = providers().find((p) => p.id === id)
+  if (!p) throw new Error(`Provider '${id}' not found in search_jobs`)
+  return p
+}
+
+// ---------------------------------------------------------------------------
+// theirstack-jobs
+// ---------------------------------------------------------------------------
+
+describe('theirstack-jobs', () => {
+  const p = () => get('theirstack-jobs')
+
+  it('isApplicable: true with title_keywords', () => {
+    expect(p().isApplicable!({ title_keywords: ['software engineer'] })).toBe(true)
+  })
+
+  it('isApplicable: true with description_keywords', () => {
+    expect(p().isApplicable!({ description_keywords: ['React', 'TypeScript'] })).toBe(true)
+  })
+
+  it('isApplicable: true with companies', () => {
+    expect(p().isApplicable!({ companies: ['ColdIQ'] })).toBe(true)
+  })
+
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only locations', () => {
+    expect(p().isApplicable!({ locations: ['Belgium'] })).toBe(false)
+  })
+
+  it('isApplicable: false on empty object', () => {
+    expect(p().isApplicable!({})).toBe(false)
+  })
+
+  it('isApplicable: false with empty arrays', () => {
+    expect(p().isApplicable!({ title_keywords: [], companies: [] })).toBe(false)
+  })
+
+  it('mapParams maps all fields to TheirStack shape', () => {
+    expect(p().mapParams({
+      title_keywords: ['software engineer'],
+      description_keywords: ['TypeScript'],
+      companies: ['ColdIQ'],
+      company_domains: ['coldiq.com'],
+      posted_after: '2026-01-01',
+      limit: 50,
+    })).toEqual({
+      body: {
+        job_title_pattern_or: ['software engineer'],
+        job_description_pattern_or: ['TypeScript'],
+        company_name_or: ['ColdIQ'],
+        company_domain_or: ['coldiq.com'],
+        posted_at_gte: '2026-01-01',
+        limit: 50,
+      },
+    })
+  })
+
+  it('mapParams passes undefined for absent fields', () => {
+    const result = p().mapParams({ title_keywords: ['engineer'] })
+    const body = result.body as Record<string, unknown>
+    expect(body.job_description_pattern_or).toBeUndefined()
+    expect(body.company_name_or).toBeUndefined()
+    expect(body.company_domain_or).toBeUndefined()
+    expect(body.posted_at_gte).toBeUndefined()
+  })
+
+  it('hasResult: true when data array is non-empty', () => {
+    expect(p().hasResult({ data: [{ id: 1, title: 'Software Engineer', company: 'ColdIQ' }] })).toBe(true)
+  })
+
+  it('hasResult: false when data is empty array', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('hasResult: false when data is null', () => {
+    expect(p().hasResult({ data: null })).toBe(false)
+  })
+
+  it('priority is 3', () => {
+    expect(p().priority).toBe(3)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Ordering: search_jobs providers sorted correctly
+// ---------------------------------------------------------------------------
+
+describe('search_jobs priority ordering', () => {
+  it('all providers are sorted by priority', () => {
+    const ps = providers()
+    for (let i = 1; i < ps.length; i++) {
+      expect(ps[i].priority).toBeGreaterThanOrEqual(ps[i - 1].priority)
+    }
+  })
+
+  it('career_site_jobs is first (priority 1)', () => {
+    expect(providers()[0].id).toBe('career_site_jobs')
+  })
+
+  it('theirstack-jobs is last (priority 3)', () => {
+    const ps = providers()
+    expect(ps[ps.length - 1].id).toBe('theirstack-jobs')
+  })
+})