@coldiq/mcp 0.1.0

package/tests/registry-enrich-person.test.ts

@@ -0,0 +1,447 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+const providers = () => getProviders('enrich_person')
+const get = (id: string) => {
+  const p = providers().find((p) => p.id === id)
+  if (!p) throw new Error(`Provider '${id}' not found in enrich_person`)
+  return p
+}
+
+// ---------------------------------------------------------------------------
+// pdl-person-enrich
+// ---------------------------------------------------------------------------
+
+describe('pdl-person-enrich', () => {
+  const p = () => get('pdl-person-enrich')
+
+  it('has no isApplicable gate (always runs)', () => {
+    expect(p().isApplicable).toBeUndefined()
+  })
+
+  it('maps all inputs to PDL fields', () => {
+    expect(p().mapParams({
+      email: 'michel@coldiq.com',
+      linkedin_url: 'https://www.linkedin.com/in/michel-lieben',
+      phone: '+1234567890',
+      first_name: 'Michel',
+      last_name: 'Lieben',
+      company_name: 'ColdIQ',
+    })).toEqual({
+      body: {
+        email: 'michel@coldiq.com',
+        profile: 'https://www.linkedin.com/in/michel-lieben',
+        phone: '+1234567890',
+        first_name: 'Michel',
+        last_name: 'Lieben',
+        company: 'ColdIQ',
+      },
+    })
+  })
+
+  it('falls back to domain when company_name absent', () => {
+    const result = p().mapParams({ domain: 'coldiq.com' })
+    expect((result.body as Record<string, unknown>).company).toBe('coldiq.com')
+  })
+
+  it('hasResult: true on 200 + data', () => {
+    expect(p().hasResult({ status: 200, data: { name: 'Michel Lieben' } })).toBe(true)
+  })
+
+  it('hasResult: false when PDL 404 (no match)', () => {
+    expect(p().hasResult({ status: 404, data: null })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 3', () => {
+    expect(p().priority).toBe(3)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// apollo-people-match
+// ---------------------------------------------------------------------------
+
+describe('apollo-people-match', () => {
+  const p = () => get('apollo-people-match')
+
+  it('has no isApplicable gate', () => {
+    expect(p().isApplicable).toBeUndefined()
+  })
+
+  it('maps fields to Apollo shape', () => {
+    expect(p().mapParams({
+      first_name: 'Michel',
+      last_name: 'Lieben',
+      email: 'michel@coldiq.com',
+      company_name: 'ColdIQ',
+      domain: 'coldiq.com',
+      linkedin_url: 'https://www.linkedin.com/in/michel-lieben',
+    })).toEqual({
+      body: {
+        first_name: 'Michel',
+        last_name: 'Lieben',
+        email: 'michel@coldiq.com',
+        organization_name: 'ColdIQ',
+        domain: 'coldiq.com',
+        linkedin_url: 'https://www.linkedin.com/in/michel-lieben',
+      },
+    })
+  })
+
+  it('hasResult: true when person object present', () => {
+    expect(p().hasResult({ person: { name: 'Michel Lieben', id: 'abc' } })).toBe(true)
+  })
+
+  it('hasResult: false when person is null', () => {
+    expect(p().hasResult({ person: null })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 4', () => {
+    expect(p().priority).toBe(4)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// blitzapi-reverse-email
+// ---------------------------------------------------------------------------
+
+describe('blitzapi-reverse-email', () => {
+  const p = () => get('blitzapi-reverse-email')
+
+  it('isApplicable: true for valid email', () => {
+    expect(p().isApplicable!({ email: 'michel@coldiq.com' })).toBe(true)
+  })
+
+  it('isApplicable: false when email absent', () => {
+    expect(p().isApplicable!({ first_name: 'Michel' })).toBe(false)
+  })
+
+  it('isApplicable: false when no @ in string', () => {
+    expect(p().isApplicable!({ email: 'notanemail' })).toBe(false)
+  })
+
+  it('mapParams wraps email in body', () => {
+    expect(p().mapParams({ email: 'michel@coldiq.com' })).toEqual({
+      body: { email: 'michel@coldiq.com' },
+    })
+  })
+
+  it('hasResult: true when person key present', () => {
+    expect(p().hasResult({ person: { name: 'Michel Lieben' } })).toBe(true)
+  })
+
+  it('hasResult: true when name key present', () => {
+    expect(p().hasResult({ name: 'Michel Lieben' } )).toBe(true)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// findymail-business-profile
+// ---------------------------------------------------------------------------
+
+describe('findymail-business-profile', () => {
+  const p = () => get('findymail-business-profile')
+
+  it('isApplicable: true for linkedin.com URL', () => {
+    expect(p().isApplicable!({ linkedin_url: 'https://www.linkedin.com/in/michel-lieben' })).toBe(true)
+  })
+
+  it('isApplicable: false when linkedin_url absent', () => {
+    expect(p().isApplicable!({ email: 'michel@coldiq.com' })).toBe(false)
+  })
+
+  it('isApplicable: false for non-linkedin URL', () => {
+    expect(p().isApplicable!({ linkedin_url: 'https://twitter.com/michel' })).toBe(false)
+  })
+
+  it('mapParams sends linkedin_url in body', () => {
+    expect(p().mapParams({ linkedin_url: 'https://www.linkedin.com/in/michel-lieben' })).toEqual({
+      body: { linkedin_url: 'https://www.linkedin.com/in/michel-lieben' },
+    })
+  })
+
+  it('hasResult: true when email present', () => {
+    expect(p().hasResult({ email: 'michel@coldiq.com', name: 'Michel Lieben' })).toBe(true)
+  })
+
+  it('hasResult: false when error key present', () => {
+    expect(p().hasResult({ error: 'Not found' })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// findymail-reverse-email
+// ---------------------------------------------------------------------------
+
+describe('findymail-reverse-email', () => {
+  const p = () => get('findymail-reverse-email')
+
+  it('isApplicable: true for email', () => {
+    expect(p().isApplicable!({ email: 'michel@coldiq.com' })).toBe(true)
+  })
+
+  it('isApplicable: false without email', () => {
+    expect(p().isApplicable!({ first_name: 'Michel' })).toBe(false)
+  })
+
+  it('mapParams sends email + with_profile:true', () => {
+    expect(p().mapParams({ email: 'michel@coldiq.com' })).toEqual({
+      body: { email: 'michel@coldiq.com', with_profile: true },
+    })
+  })
+
+  it('hasResult: true when name present', () => {
+    expect(p().hasResult({ name: 'Michel Lieben', email: 'michel@coldiq.com' })).toBe(true)
+  })
+
+  it('hasResult: false when error present', () => {
+    expect(p().hasResult({ error: 'Not found' })).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// icypeas-scrape-profile
+// ---------------------------------------------------------------------------
+
+describe('icypeas-scrape-profile', () => {
+  const p = () => get('icypeas-scrape-profile')
+
+  it('isApplicable: true for linkedin.com URL', () => {
+    expect(p().isApplicable!({ linkedin_url: 'https://www.linkedin.com/in/michel-lieben' })).toBe(true)
+  })
+
+  it('isApplicable: false when not a linkedin URL', () => {
+    expect(p().isApplicable!({ linkedin_url: 'https://example.com/michel' })).toBe(false)
+  })
+
+  it('isApplicable: false when linkedin_url absent', () => {
+    expect(p().isApplicable!({ email: 'michel@coldiq.com' })).toBe(false)
+  })
+
+  it('mapParams maps linkedin_url to url field', () => {
+    expect(p().mapParams({ linkedin_url: 'https://www.linkedin.com/in/michel-lieben' })).toEqual({
+      body: { url: 'https://www.linkedin.com/in/michel-lieben' },
+    })
+  })
+
+  it('hasResult: true when success + profile', () => {
+    expect(p().hasResult({ success: true, profile: { name: 'Michel Lieben' } })).toBe(true)
+  })
+
+  it('hasResult: false when success:false', () => {
+    expect(p().hasResult({ success: false, profile: null })).toBe(false)
+  })
+
+  it('hasResult: false on empty', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// icypeas-url-search-profile
+// ---------------------------------------------------------------------------
+
+describe('icypeas-url-search-profile', () => {
+  const p = () => get('icypeas-url-search-profile')
+
+  it('isApplicable: true with name + company_name', () => {
+    expect(p().isApplicable!({ first_name: 'Michel', last_name: 'Lieben', company_name: 'ColdIQ' })).toBe(true)
+  })
+
+  it('isApplicable: true with name + domain', () => {
+    expect(p().isApplicable!({ first_name: 'Michel', last_name: 'Lieben', domain: 'coldiq.com' })).toBe(true)
+  })
+
+  it('isApplicable: false with only name (no company)', () => {
+    expect(p().isApplicable!({ first_name: 'Michel', last_name: 'Lieben' })).toBe(false)
+  })
+
+  it('isApplicable: false with only email', () => {
+    expect(p().isApplicable!({ email: 'michel@coldiq.com' })).toBe(false)
+  })
+
+  it('mapParams converts to Icypeas camelCase fields', () => {
+    expect(p().mapParams({ first_name: 'Michel', last_name: 'Lieben', company_name: 'ColdIQ' })).toEqual({
+      body: { firstname: 'Michel', lastname: 'Lieben', companyOrDomain: 'ColdIQ' },
+    })
+  })
+
+  it('mapParams prefers company_name over domain', () => {
+    const r = p().mapParams({ first_name: 'Michel', last_name: 'Lieben', company_name: 'ColdIQ', domain: 'coldiq.com' })
+    expect((r.body as Record<string, unknown>).companyOrDomain).toBe('ColdIQ')
+  })
+
+  it('hasResult: true when profileUrl contains linkedin.com', () => {
+    expect(p().hasResult({ profileUrl: 'https://www.linkedin.com/in/michel-lieben' })).toBe(true)
+  })
+
+  it('hasResult: false when profileUrl absent', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('hasResult: false when profileUrl is not linkedin', () => {
+    expect(p().hasResult({ profileUrl: 'https://example.com' })).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ai-ark-reverse-lookup
+// ---------------------------------------------------------------------------
+
+describe('ai-ark-reverse-lookup', () => {
+  const p = () => get('ai-ark-reverse-lookup')
+
+  it('isApplicable: true for email', () => {
+    expect(p().isApplicable!({ email: 'michel@coldiq.com' })).toBe(true)
+  })
+
+  it('isApplicable: true for phone', () => {
+    expect(p().isApplicable!({ phone: '+32477123456' })).toBe(true)
+  })
+
+  it('isApplicable: false without email or phone', () => {
+    expect(p().isApplicable!({ first_name: 'Michel' })).toBe(false)
+  })
+
+  it('mapParams prefers email over phone', () => {
+    expect(p().mapParams({ email: 'michel@coldiq.com', phone: '+32477123456' })).toEqual({
+      body: { search: 'michel@coldiq.com' },
+    })
+  })
+
+  it('mapParams uses phone when no email', () => {
+    expect(p().mapParams({ phone: '+32477123456' })).toEqual({
+      body: { search: '+32477123456' },
+    })
+  })
+
+  it('hasResult: true when name present', () => {
+    expect(p().hasResult({ name: 'Michel Lieben', email: 'michel@coldiq.com' })).toBe(true)
+  })
+
+  it('hasResult: false on empty', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// icypeas-reverse-email-lookup
+// ---------------------------------------------------------------------------
+
+describe('icypeas-reverse-email-lookup', () => {
+  const p = () => get('icypeas-reverse-email-lookup')
+
+  it('isApplicable: true for email', () => {
+    expect(p().isApplicable!({ email: 'michel@coldiq.com' })).toBe(true)
+  })
+
+  it('isApplicable: false without email', () => {
+    expect(p().isApplicable!({ first_name: 'Michel' })).toBe(false)
+  })
+
+  it('mapParams sends email in body', () => {
+    expect(p().mapParams({ email: 'michel@coldiq.com' })).toEqual({
+      body: { email: 'michel@coldiq.com' },
+    })
+  })
+
+  it('hasResult: true when non-empty profiles array', () => {
+    expect(p().hasResult({ profiles: [{ name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: true when success + data', () => {
+    expect(p().hasResult({ success: true, data: { name: 'Michel Lieben' } })).toBe(true)
+  })
+
+  it('hasResult: false when profiles is empty array', () => {
+    expect(p().hasResult({ profiles: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// pdl-person-identify
+// ---------------------------------------------------------------------------
+
+describe('pdl-person-identify', () => {
+  const p = () => get('pdl-person-identify')
+
+  it('has no isApplicable gate', () => {
+    expect(p().isApplicable).toBeUndefined()
+  })
+
+  it('maps inputs to PDL fields', () => {
+    expect(p().mapParams({
+      email: 'michel@coldiq.com',
+      first_name: 'Michel',
+      last_name: 'Lieben',
+      company_name: 'ColdIQ',
+    })).toEqual({
+      body: {
+        email: 'michel@coldiq.com',
+        profile: undefined,
+        phone: undefined,
+        first_name: 'Michel',
+        last_name: 'Lieben',
+        company: 'ColdIQ',
+      },
+    })
+  })
+
+  it('hasResult: true when matches array is non-empty', () => {
+    expect(p().hasResult({ status: 200, matches: [{ data: { name: 'Michel Lieben' }, match_score: 80 }], total: 1 })).toBe(true)
+  })
+
+  it('hasResult: false when matches is empty', () => {
+    expect(p().hasResult({ status: 200, matches: [], total: 0 })).toBe(false)
+  })
+
+  it('hasResult: false when status != 200', () => {
+    expect(p().hasResult({ status: 404, matches: [] })).toBe(false)
+  })
+
+  it('priority is 12 (last fallback)', () => {
+    expect(p().priority).toBe(12)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Ordering: enrich_person providers sorted correctly
+// ---------------------------------------------------------------------------
+
+describe('enrich_person 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('linkupapi-profile-enrich is first (priority 1)', () => {
+    expect(providers()[0].id).toBe('linkupapi-profile-enrich')
+  })
+
+  it('pdl-person-identify is last (priority 12)', () => {
+    const ps = providers()
+    expect(ps[ps.length - 1].id).toBe('pdl-person-identify')
+  })
+})

package/tests/registry-fetch-page-content.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+const providers = () => getProviders('fetch_page_content')
+const get = (id: string) => {
+  const p = providers().find((p) => p.id === id)
+  if (!p) throw new Error(`Provider '${id}' not found in fetch_page_content`)
+  return p
+}
+
+// ---------------------------------------------------------------------------
+// exa-contents
+// ---------------------------------------------------------------------------
+
+describe('exa-contents', () => {
+  const p = () => get('exa-contents')
+
+  it('has no isApplicable gate (always runs)', () => {
+    expect(p().isApplicable).toBeUndefined()
+  })
+
+  it('mapParams with defaults: text=true, no summary', () => {
+    expect(p().mapParams({
+      urls: ['https://coldiq.com', 'https://microsoft.com'],
+      include_text: true,
+      include_summary: false,
+    })).toEqual({
+      body: {
+        urls: ['https://coldiq.com', 'https://microsoft.com'],
+        text: true,
+        summary: undefined,
+      },
+    })
+  })
+
+  it('mapParams with include_summary=true adds summary object', () => {
+    const result = p().mapParams({
+      urls: ['https://coldiq.com'],
+      include_text: true,
+      include_summary: true,
+    })
+    expect((result.body as Record<string, unknown>).summary).toEqual({})
+  })
+
+  it('mapParams with include_text=false omits text', () => {
+    const result = p().mapParams({
+      urls: ['https://coldiq.com'],
+      include_text: false,
+      include_summary: false,
+    })
+    expect((result.body as Record<string, unknown>).text).toBeUndefined()
+  })
+
+  it('hasResult: true when results array non-empty', () => {
+    expect(p().hasResult({
+      results: [{ url: 'https://coldiq.com', text: 'ColdIQ is a sales engagement platform.' }],
+    })).toBe(true)
+  })
+
+  it('hasResult: false when results is empty', () => {
+    expect(p().hasResult({ results: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 1', () => {
+    expect(p().priority).toBe(1)
+  })
+
+  it('endpoint is /exa/contents', () => {
+    expect(p().endpoint).toBe('/exa/contents')
+    expect(p().method).toBe('POST')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Ordering
+// ---------------------------------------------------------------------------
+
+describe('fetch_page_content provider list', () => {
+  it('has exactly one provider', () => {
+    expect(providers()).toHaveLength(1)
+  })
+
+  it('exa-contents is the only provider', () => {
+    expect(providers()[0].id).toBe('exa-contents')
+  })
+})