@coldiq/mcp 0.3.4 → 0.3.6

package/tests/tools/list-data-sources.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from 'vitest'
+import { listDataSourcesHandler } from '../../src/tools/list-data-sources.js'
+
+interface Source { name: string; strength?: string }
+interface CapabilityCatalog { tool: string; label: string; sources: Source[] }
+
+function parse(result: { content: { text: string }[]; isError?: boolean }) {
+  return JSON.parse(result.content[0].text)
+}
+
+function rowFor(caps: CapabilityCatalog[], toolContains: string): CapabilityCatalog | undefined {
+  return caps.find((c) => c.tool.includes(toolContains))
+}
+
+describe('list_data_sources handler', () => {
+  it('lists every capability-routed category with branded sources', async () => {
+    const parsed = parse(await listDataSourcesHandler({}))
+    const caps: CapabilityCatalog[] = parsed.data.capabilities
+    expect(parsed.data.intro).toContain('routes')
+    expect(caps.length).toBeGreaterThan(10)
+
+    const companies = rowFor(caps, 'search_companies')!
+    const names = companies.sources.map((s) => s.name)
+    expect(names).toContain('Apollo')
+    expect(names).toContain('TheirStack')
+
+    const emails = rowFor(caps, 'find_email')!
+    expect(emails.sources.map((s) => s.name)).toContain('FullEnrich')
+  })
+
+  it('never emits a raw slug or "Apify" in any source name', async () => {
+    const parsed = parse(await listDataSourcesHandler({}))
+    const caps: CapabilityCatalog[] = parsed.data.capabilities
+    for (const cap of caps) {
+      for (const src of cap.sources) {
+        expect(src.name).not.toContain('_')
+        expect(src.name.toLowerCase()).not.toContain('apify')
+      }
+    }
+  })
+
+  it('dedupes vendors within a category (one row per brand)', async () => {
+    const parsed = parse(await listDataSourcesHandler({}))
+    const caps: CapabilityCatalog[] = parsed.data.capabilities
+    const companies = rowFor(caps, 'search_companies')!
+    const names = companies.sources.map((s) => s.name)
+    // search_companies has limadata + limadata-prospect-* + linkupapi-* internally
+    expect(names.filter((n) => n === 'LimaData')).toHaveLength(1)
+    expect(names.filter((n) => n === 'LinkupAPI')).toHaveLength(1)
+    // every row carries the metadata a frontend needs
+    for (const cap of caps) {
+      expect(typeof cap.tool).toBe('string')
+      expect(typeof cap.label).toBe('string')
+      expect(cap.sources.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('carries curated strengths on the well-known sources', async () => {
+    const parsed = parse(await listDataSourcesHandler({}))
+    const caps: CapabilityCatalog[] = parsed.data.capabilities
+    const theirstack = rowFor(caps, 'search_companies')!.sources.find((s) => s.name === 'TheirStack')!
+    expect(theirstack.strength).toBeTruthy()
+    expect(theirstack.strength).toContain('technographic')
+  })
+
+  it('filters to a single category by tool name', async () => {
+    const parsed = parse(await listDataSourcesHandler({ capability: 'find_email' }))
+    const caps: CapabilityCatalog[] = parsed.data.capabilities
+    expect(caps).toHaveLength(1)
+    expect(caps[0].tool).toContain('find_email')
+  })
+
+  it('accepts the find_emails alias for the shared email row', async () => {
+    const parsed = parse(await listDataSourcesHandler({ capability: 'find_emails' }))
+    expect(parsed.data.capabilities).toHaveLength(1)
+    expect(parsed.data.capabilities[0].tool).toContain('find_email')
+  })
+
+  it('returns an error payload listing valid values for an unknown category', async () => {
+    const result = await listDataSourcesHandler({ capability: 'nonsense' })
+    expect(result.isError).toBe(true)
+    const parsed = parse(result)
+    expect(parsed.error).toContain('not a recognized category')
+    expect(parsed.valid_capabilities).toContain('search_companies')
+  })
+})

package/tests/utils/provider-display.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest'
+import { providerDisplayName } from '../../src/utils/provider-display.js'
+
+describe('providerDisplayName', () => {
+  it('maps known vendor ids to branded names', () => {
+    expect(providerDisplayName('fullenrich')).toBe('FullEnrich')
+    expect(providerDisplayName('theirstack')).toBe('TheirStack')
+    expect(providerDisplayName('pdl')).toBe('People Data Labs')
+  })
+
+  it('collapses vendor variants to one brand', () => {
+    expect(providerDisplayName('limadata-work-email')).toBe('LimaData')
+    expect(providerDisplayName('limadata-prospect-url')).toBe('LimaData')
+    expect(providerDisplayName('signalbase-funding')).toBe('SignalBase')
+    expect(providerDisplayName('linkupapi-by-domain')).toBe('LinkupAPI')
+  })
+
+  it('brands Apify-backed scrapers as their data source, never raw slug', () => {
+    expect(providerDisplayName('reddit_ads')).toBe('Reddit Ads')
+    expect(providerDisplayName('linkedin_ad_library')).toBe('LinkedIn Ad Library')
+    expect(providerDisplayName('google_maps')).toBe('Google Maps')
+  })
+
+  it('title-cases unmapped ids as a defensive fallback', () => {
+    expect(providerDisplayName('some-new-vendor')).toBe('Some New Vendor')
+    expect(providerDisplayName('good')).toBe('Good')
+  })
+
+  it('never returns a raw slug or the word "Apify"', () => {
+    const ids = [
+      'limadata-work-email', 'reddit_ads', 'fullenrich', 'ai-ark-people',
+      'linkupapi-validate', 'theirstack-buying-intents', 'completely_unknown_slug',
+    ]
+    for (const id of ids) {
+      const name = providerDisplayName(id)
+      expect(name).not.toContain('_')
+      expect(name.toLowerCase()).not.toContain('apify')
+    }
+  })
+})

package/tests/utils/selection-insight.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest'
+import { buildSelectionInsight } from '../../src/utils/selection-insight.js'
+
+describe('buildSelectionInsight', () => {
+  describe('capability routing (gated-in, not fallback)', () => {
+    it('ties the choice to the distinctive input signal', () => {
+      const r = buildSelectionInsight(
+        'search_companies',
+        'theirstack',
+        { technologies: ['Salesforce'], keywords: ['saas'] },
+        { wasFallback: false, pinnedByUser: false },
+      )
+      expect(r).toBeDefined()
+      expect(r!.insight).toContain('TheirStack')
+      expect(r!.insight).toContain('technographic')
+      // tech-stack is the most distinctive signal → drives the "matched to your …" clause
+      expect(r!.insight).toContain('tech-stack filter')
+      expect(r!.insight.startsWith('Routed to')).toBe(true)
+      expect(r!.signals[0]).toBe('tech-stack filter')
+    })
+
+    it('omits the signal clause when no distinctive input is present', () => {
+      const r = buildSelectionInsight(
+        'enrich_company',
+        'apollo',
+        {},
+        { wasFallback: false, pinnedByUser: false },
+      )
+      expect(r!.insight).toBe('Routed to Apollo for its deep firmographic enrichment.')
+      expect(r!.signals).toEqual([])
+    })
+  })
+
+  describe('fallthrough (softened wording)', () => {
+    it('states coverage without claiming it was the upfront best fit', () => {
+      const r = buildSelectionInsight(
+        'find_email',
+        'fullenrich',
+        { domain: 'coldiq.com', first_name: 'Michel' },
+        { wasFallback: true, pinnedByUser: false },
+      )
+      expect(r!.insight).toContain('FullEnrich')
+      expect(r!.insight).toContain('returned the match here')
+      // never the confident "Routed to" framing on a fallthrough
+      expect(r!.insight.startsWith('Routed to')).toBe(false)
+    })
+  })
+
+  describe('user-pinned providers', () => {
+    it('does not claim ColdIQ chose it', () => {
+      const r = buildSelectionInsight(
+        'search_companies',
+        'theirstack',
+        { technologies: ['Salesforce'] },
+        { wasFallback: false, pinnedByUser: true },
+      )
+      expect(r!.insight).toBe('Used TheirStack as requested.')
+      // signals still surfaced for UI
+      expect(r!.signals).toContain('tech-stack filter')
+    })
+  })
+
+  describe('no curated edge — plain true line, no fabrication', () => {
+    it('emits a generic line for an unmapped provider', () => {
+      const r = buildSelectionInsight(
+        'enrich_company',
+        'good', // synthetic id, not in STRENGTHS
+        { domain: 'coldiq.com' },
+        { wasFallback: false, pinnedByUser: false },
+      )
+      expect(r!.insight).toBe('Good matched your company domain for this company enrichment.')
+      // no invented "deep/strong/broad coverage" claim
+      expect(r!.insight).not.toMatch(/deep|strong|broad|coverage|specializ/)
+    })
+
+    it('falls back to the barest true line with no signals', () => {
+      const r = buildSelectionInsight(
+        'search_reddit',
+        'mystery_provider',
+        {},
+        { wasFallback: false, pinnedByUser: false },
+      )
+      expect(r!.insight).toBe('Mystery Provider matched this Reddit search.')
+    })
+  })
+
+  describe('find_emails batch signals', () => {
+    it('detects LinkedIn URLs and name+domain across people', () => {
+      const r = buildSelectionInsight(
+        'find_emails',
+        'fullenrich',
+        { people: [{ id: '1', first_name: 'Michel', domain: 'coldiq.com', linkedin_url: 'https://linkedin.com/in/x' }] },
+        { wasFallback: true, pinnedByUser: false },
+      )
+      expect(r!.insight).toContain('FullEnrich')
+      expect(r!.signals).toContain('LinkedIn URLs')
+      expect(r!.signals).toContain('name + domain')
+    })
+  })
+
+  describe('honesty — fallthrough never claims an upfront best-fit judgment', () => {
+    it('uses the softened framing and no superiority superlatives', () => {
+      const r = buildSelectionInsight(
+        'find_people',
+        'apollo',
+        { job_titles: ['CEO'] },
+        { wasFallback: true, pinnedByUser: false },
+      )
+      expect(r!.insight).toContain('returned the match here')
+      expect(r!.insight.startsWith('Routed to')).toBe(false)
+      expect(r!.insight.toLowerCase()).not.toMatch(/\bbest\b|deepest|largest/)
+    })
+  })
+})