@coldiq/mcp 0.1.0

package/tests/registry-find-signals.test.ts

@@ -0,0 +1,470 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+const providers = () => getProviders('find_signals')
+const get = (id: string) => {
+  const p = providers().find((p) => p.id === id)
+  if (!p) throw new Error(`Provider '${id}' not found in find_signals`)
+  return p
+}
+
+// ---------------------------------------------------------------------------
+// signalbase-funding
+// ---------------------------------------------------------------------------
+
+describe('signalbase-funding', () => {
+  const p = () => get('signalbase-funding')
+
+  it('isApplicable: true for funding signal_type', () => {
+    expect(p().isApplicable!({ signal_type: 'funding' })).toBe(true)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'acquisition' })).toBe(false)
+    expect(p().isApplicable!({ signal_type: 'hiring' })).toBe(false)
+    expect(p().isApplicable!({ signal_type: 'intent' })).toBe(false)
+  })
+
+  it('mapParams builds correct query params', () => {
+    const result = p().mapParams({
+      signal_type: 'funding',
+      companies: ['ColdIQ'],
+      since: '2026-01-01',
+      industries: ['Software', 'SaaS'],
+      countries: ['US', 'GB'],
+      limit: 20,
+    })
+    expect(result).toEqual({
+      queryParams: {
+        company_name: 'ColdIQ',
+        dateFrom: '2026-01-01',
+        industry: 'Software,SaaS',
+        countries: 'US,GB',
+        limit: '20',
+      },
+    })
+  })
+
+  it('mapParams omits missing optional fields', () => {
+    const result = p().mapParams({ signal_type: 'funding', limit: 10 })
+    const qp = result.queryParams as Record<string, string>
+    expect(qp.company_name).toBeUndefined()
+    expect(qp.dateFrom).toBeUndefined()
+    expect(qp.industry).toBeUndefined()
+    expect(qp.countries).toBeUndefined()
+    expect(qp.limit).toBe('10')
+  })
+
+  it('mapParams caps limit at 100', () => {
+    const result = p().mapParams({ signal_type: 'funding', limit: 999 })
+    expect((result.queryParams as Record<string, string>).limit).toBe('100')
+  })
+
+  it('hasResult: true when data array non-empty', () => {
+    expect(p().hasResult({ data: [{ company: 'ColdIQ', amount: 1000000 }] })).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 1', () => {
+    expect(p().priority).toBe(1)
+  })
+
+  // Signalbase data quality bug: some records populate company* fields with investor data.
+  // postFilter detects when companyName matches an investor name and fixes it from the slug.
+  describe('postFilter: investor-as-company fix', () => {
+    const buggedSignal = {
+      companyName: 'Newfund',
+      companySlug: 'fermeate',
+      companyWebsite: 'newfundcap.com',
+      companyLinkedin: 'linkedin.com/company/newfund-management',
+      companyLogo: 'https://images.trysignalbase.com/Newfund.png',
+      companyDescription: 'Newfund Capital is an early-stage VC firm...',
+      investors: [
+        { id: 'abc', name: 'Newfund', type: null },
+        { id: 'def', name: 'SOSV', type: 'VC firm' },
+      ],
+      amount: 2000000,
+    }
+
+    it('fixes companyName from slug when companyName matches an investor', () => {
+      const result = p().postFilter!({ data: [buggedSignal] }, {}) as { data: Array<Record<string, unknown>> }
+      expect(result.data[0].companyName).toBe('Fermeate')
+    })
+
+    it('nulls investor-tainted company fields', () => {
+      const result = p().postFilter!({ data: [buggedSignal] }, {}) as { data: Array<Record<string, unknown>> }
+      const fixed = result.data[0]
+      expect(fixed.companyWebsite).toBeNull()
+      expect(fixed.companyLinkedin).toBeNull()
+      expect(fixed.companyLogo).toBeNull()
+      expect(fixed.companyDescription).toBeNull()
+    })
+
+    it('preserves all other signal fields', () => {
+      const result = p().postFilter!({ data: [buggedSignal] }, {}) as { data: Array<Record<string, unknown>> }
+      expect(result.data[0].amount).toBe(2000000)
+      expect(result.data[0].investors).toEqual(buggedSignal.investors)
+    })
+
+    it('leaves clean records untouched', () => {
+      const cleanSignal = {
+        companyName: 'Crush Security',
+        companySlug: 'crush-security',
+        companyWebsite: 'crushsecurity.com',
+        companyLinkedin: 'linkedin.com/company/crush-security',
+        companyLogo: 'https://images.trysignalbase.com/Crush Security.png',
+        companyDescription: 'Cybersecurity compliance remediation.',
+        investors: [{ id: 'xyz', name: 'SomeVC', type: 'VC' }],
+        amount: 3000000,
+      }
+      const result = p().postFilter!({ data: [cleanSignal] }, {}) as { data: Array<Record<string, unknown>> }
+      expect(result.data[0].companyName).toBe('Crush Security')
+      expect(result.data[0].companyWebsite).toBe('crushsecurity.com')
+    })
+
+    it('handles empty investors array without error', () => {
+      const signal = { companyName: 'Fermeate', companySlug: 'fermeate', investors: [] }
+      expect(() => p().postFilter!({ data: [signal] }, {})).not.toThrow()
+    })
+
+    it('handles missing data array without error', () => {
+      expect(() => p().postFilter!({}, {})).not.toThrow()
+    })
+  })
+
+  // Signalbase stamps all sources[].publishedAt with occurredAt, making date comparison
+  // useless. We detect stale signals by extracting years embedded in news article URLs.
+  describe('postFilter: stale signal filter (Bug 2)', () => {
+    const staleSignal = {
+      companyName: 'TRIGO',
+      companySlug: 'trigo-3',
+      occurredAt: '2026-04-23T08:08:14.975Z',
+      investors: [],
+      sources: [
+        { url: 'https://linkedin.com/posts/abc-activity-xyz', sourceType: 'social_media', publishedAt: '2026-04-23T08:08:14.975Z' },
+        { url: 'https://techcrunch.com/2019/09/16/trigo-raises-22m/', sourceType: 'news_article', publishedAt: '2026-04-23T08:08:14.975Z' },
+        { url: 'https://fintech.global/2019/09/16/trigo-raises-22m/', sourceType: 'news_article', publishedAt: '2026-04-23T08:08:14.975Z' },
+      ],
+    }
+    const freshSignal = {
+      companyName: 'Fermeate',
+      companySlug: 'fermeate',
+      occurredAt: '2026-04-27T13:28:00.056Z',
+      investors: [],
+      sources: [
+        { url: 'https://agfundernews.com/fermeate-raises-2m-step-change', sourceType: 'news_article', publishedAt: '2026-04-27T13:28:00.056Z' },
+      ],
+    }
+
+    it('drops signals where a news article URL embeds a year 5+ before occurredAt', () => {
+      const result = p().postFilter!({ data: [staleSignal] }, {}) as { data: unknown[] }
+      expect(result.data).toHaveLength(0)
+    })
+
+    it('keeps signals where news article URLs are recent', () => {
+      const result = p().postFilter!({ data: [freshSignal] }, {}) as { data: unknown[] }
+      expect(result.data).toHaveLength(1)
+    })
+
+    it('ignores year-like patterns in social_media URLs', () => {
+      const socialWithOldYear = {
+        ...freshSignal,
+        sources: [{ url: 'https://linkedin.com/posts/2019/09/old-post', sourceType: 'social_media' }],
+      }
+      const result = p().postFilter!({ data: [socialWithOldYear] }, {}) as { data: unknown[] }
+      expect(result.data).toHaveLength(1)
+    })
+
+    it('keeps signals where news URLs have no embedded year', () => {
+      const noYearUrl = {
+        ...freshSignal,
+        sources: [{ url: 'https://techcrunch.com/trigo-raises-22m', sourceType: 'news_article' }],
+      }
+      const result = p().postFilter!({ data: [noYearUrl] }, {}) as { data: unknown[] }
+      expect(result.data).toHaveLength(1)
+    })
+
+    it('filters stale signals and keeps fresh ones from a mixed batch', () => {
+      const result = p().postFilter!({ data: [staleSignal, freshSignal] }, {}) as { data: Array<Record<string, unknown>> }
+      expect(result.data).toHaveLength(1)
+      expect(result.data[0].companyName).toBe('Fermeate')
+    })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// signalbase-acquisition
+// ---------------------------------------------------------------------------
+
+describe('signalbase-acquisition', () => {
+  const p = () => get('signalbase-acquisition')
+
+  it('isApplicable: true for acquisition signal_type', () => {
+    expect(p().isApplicable!({ signal_type: 'acquisition' })).toBe(true)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'funding' })).toBe(false)
+  })
+
+  it('mapParams builds correct query params', () => {
+    const result = p().mapParams({
+      signal_type: 'acquisition',
+      companies: ['Microsoft'],
+      since: '2026-01-01',
+      limit: 15,
+    })
+    expect((result.queryParams as Record<string, string>).company_name).toBe('Microsoft')
+    expect((result.queryParams as Record<string, string>).dateFrom).toBe('2026-01-01')
+    expect((result.queryParams as Record<string, string>).limit).toBe('15')
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ company: 'Startup' }] })).toBe(true)
+  })
+
+  it('hasResult: false on empty data', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('priority is 2', () => {
+    expect(p().priority).toBe(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// signalbase-hiring
+// ---------------------------------------------------------------------------
+
+describe('signalbase-hiring', () => {
+  const p = () => get('signalbase-hiring')
+
+  it('isApplicable: true for hiring signal_type', () => {
+    expect(p().isApplicable!({ signal_type: 'hiring' })).toBe(true)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'funding' })).toBe(false)
+  })
+
+  it('mapParams uses search field for companies', () => {
+    const result = p().mapParams({ signal_type: 'hiring', companies: ['ColdIQ'], limit: 10 })
+    expect((result.queryParams as Record<string, string>).search).toBe('ColdIQ')
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ title: 'VP Sales', company: 'ColdIQ' }] })).toBe(true)
+  })
+
+  it('priority is 3', () => {
+    expect(p().priority).toBe(3)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// signalbase-job-change
+// ---------------------------------------------------------------------------
+
+describe('signalbase-job-change', () => {
+  const p = () => get('signalbase-job-change')
+
+  it('isApplicable: true for job_change signal_type', () => {
+    expect(p().isApplicable!({ signal_type: 'job_change' })).toBe(true)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'hiring' })).toBe(false)
+  })
+
+  it('mapParams uses company_name field', () => {
+    const result = p().mapParams({ signal_type: 'job_change', companies: ['ColdIQ'], limit: 10 })
+    expect((result.queryParams as Record<string, string>).company_name).toBe('ColdIQ')
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ person: 'Michel Lieben', new_role: 'CEO' }] })).toBe(true)
+  })
+
+  it('priority is 4', () => {
+    expect(p().priority).toBe(4)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// theirstack-buying-intents
+// ---------------------------------------------------------------------------
+
+describe('theirstack-buying-intents', () => {
+  const p = () => get('theirstack-buying-intents')
+
+  it('isApplicable: true for intent with companies', () => {
+    expect(p().isApplicable!({ signal_type: 'intent', companies: ['ColdIQ'] })).toBe(true)
+  })
+
+  it('isApplicable: true for intent with domains', () => {
+    expect(p().isApplicable!({ signal_type: 'intent', domains: ['coldiq.com'] })).toBe(true)
+  })
+
+  it('isApplicable: false for intent with no companies or domains', () => {
+    expect(p().isApplicable!({ signal_type: 'intent' })).toBe(false)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'funding' })).toBe(false)
+  })
+
+  it('mapParams includes company_name_or when companies present', () => {
+    const result = p().mapParams({ signal_type: 'intent', companies: ['ColdIQ', 'HubSpot'] })
+    expect((result.body as Record<string, unknown>).company_name_or).toEqual(['ColdIQ', 'HubSpot'])
+  })
+
+  it('mapParams includes company_domain when domains present', () => {
+    const result = p().mapParams({ signal_type: 'intent', domains: ['coldiq.com'] })
+    expect((result.body as Record<string, unknown>).company_domain).toBe('coldiq.com')
+  })
+
+  it('mapParams omits absent fields', () => {
+    const result = p().mapParams({ signal_type: 'intent' })
+    const body = result.body as Record<string, unknown>
+    expect(body.company_name_or).toBeUndefined()
+    expect(body.company_domain).toBeUndefined()
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ company: 'ColdIQ', intents: ['crm'] }] })).toBe(true)
+  })
+
+  it('hasResult: false on empty data', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('priority is 5', () => {
+    expect(p().priority).toBe(5)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// predictleads-financing
+// ---------------------------------------------------------------------------
+
+describe('predictleads-financing', () => {
+  const p = () => get('predictleads-financing')
+
+  it('isApplicable: true for funding (fallback)', () => {
+    expect(p().isApplicable!({ signal_type: 'funding' })).toBe(true)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'news' })).toBe(false)
+  })
+
+  it('mapParams passes company_location and limit', () => {
+    const result = p().mapParams({ signal_type: 'funding', countries: ['United States'], limit: 30 })
+    expect(result).toEqual({ queryParams: { company_location: 'United States', limit: '30' } })
+  })
+
+  it('mapParams omits company_location when no countries', () => {
+    const result = p().mapParams({ signal_type: 'funding', limit: 10 })
+    expect((result.queryParams as Record<string, string>).company_location).toBeUndefined()
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ company: 'ColdIQ', amount: 500000 }] })).toBe(true)
+  })
+
+  it('priority is 6 (fallback after signalbase-funding)', () => {
+    expect(p().priority).toBe(6)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// predictleads-news
+// ---------------------------------------------------------------------------
+
+describe('predictleads-news', () => {
+  const p = () => get('predictleads-news')
+
+  it('isApplicable: true for news signal_type', () => {
+    expect(p().isApplicable!({ signal_type: 'news' })).toBe(true)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'funding' })).toBe(false)
+  })
+
+  it('mapParams passes company_location and limit', () => {
+    const result = p().mapParams({ signal_type: 'news', countries: ['Belgium'], limit: 20 })
+    expect(result).toEqual({ queryParams: { company_location: 'Belgium', limit: '20' } })
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ title: 'ColdIQ raises $1M' }] })).toBe(true)
+  })
+
+  it('priority is 7', () => {
+    expect(p().priority).toBe(7)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// predictleads-startup-posts
+// ---------------------------------------------------------------------------
+
+describe('predictleads-startup-posts', () => {
+  const p = () => get('predictleads-startup-posts')
+
+  it('isApplicable: true for startup_post signal_type', () => {
+    expect(p().isApplicable!({ signal_type: 'startup_post' })).toBe(true)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'news' })).toBe(false)
+  })
+
+  it('mapParams passes published_at_from and limit', () => {
+    const result = p().mapParams({ signal_type: 'startup_post', since: '2026-01-01', limit: 15 })
+    expect(result).toEqual({ queryParams: { published_at_from: '2026-01-01', limit: '15' } })
+  })
+
+  it('mapParams omits published_at_from when no since', () => {
+    const result = p().mapParams({ signal_type: 'startup_post', limit: 5 })
+    expect((result.queryParams as Record<string, string>).published_at_from).toBeUndefined()
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ title: 'ColdIQ on Product Hunt' }] })).toBe(true)
+  })
+
+  it('priority is 8', () => {
+    expect(p().priority).toBe(8)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Ordering
+// ---------------------------------------------------------------------------
+
+describe('find_signals 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('signalbase-funding is first (priority 1)', () => {
+    expect(providers()[0].id).toBe('signalbase-funding')
+  })
+
+  it('predictleads-startup-posts is last (priority 8)', () => {
+    const ps = providers()
+    expect(ps[ps.length - 1].id).toBe('predictleads-startup-posts')
+  })
+})