@coldiq/mcp 0.2.7 → 0.3.0

package/src/tools/search-reddit.ts

@@ -5,25 +5,31 @@ import { resolvePreferredProviders, getProvidersForCapability } from '../utils/p
 export const searchRedditName = 'search_reddit'
 
 export const searchRedditDescription =
-  'Scrape Reddit posts and comments via 1 provider (Reddit Scraper). Requires at least one subreddit or post URL. Optionally filter by keyword query within those URLs. Supports sorting, time filters, comment inclusion. Async (~30–120s). Cost: 1 credit per item returned.'
+  'Scrape Reddit posts, comments, communities, or users via 1 provider (Reddit Scraper). Provide subreddit/post/user URLs and/or a keyword query. Optionally scope a query to one community, sort, filter by time, include comments, and limit by date. Async (~30–120s). Cost: 1 credit per item returned.'
 
 export const searchRedditSchema = {
-  start_urls: z.array(z.string().url()).min(1).max(25)
-    .describe('Reddit URLs to scrape (subreddit, post, or search URL). At least 1 required. Up to 25. Example: ["https://www.reddit.com/r/sales/"]'),
+  start_urls: z.array(z.string().url()).max(25).optional()
+    .describe('Reddit URLs to scrape (subreddit, post, user, or search URL). Up to 25. Provide this and/or query. Example: ["https://www.reddit.com/r/sales/"]'),
   query: z.string().optional()
-    .describe('Optional keyword filter applied within the provided URLs e.g. "best CRM for startups".'),
-  type: z.enum(['posts', 'comments']).default('posts')
-    .describe('Scrape posts or comments.'),
-  sort: z.enum(['relevance', 'hot', 'top', 'new', 'comments']).optional()
+    .describe('Keyword search query e.g. "best CRM for startups". Provide this and/or start_urls. When combined with a bare subreddit start_url (e.g. ".../r/sales/"), the query is applied as an in-subreddit search so only matching posts are returned (a bare subreddit URL alone would otherwise return its whole feed, ignoring the keyword).'),
+  search_type: z.enum(['posts', 'comments', 'communities', 'users']).default('posts')
+    .describe('What the search query returns: posts, comments, communities, or users.'),
+  search_community_name: z.string().optional()
+    .describe('Restrict the search query to a single community e.g. "sales".'),
+  sort: z.enum(['relevance', 'hot', 'top', 'new', 'rising', 'comments']).optional()
     .describe('Sort order for results.'),
   time: z.enum(['hour', 'day', 'week', 'month', 'year', 'all']).optional()
     .describe('Time filter.'),
   limit: z.number().int().min(1).max(200).default(10)
     .describe('Max items to return (1–200). 1 credit per item.'),
-  max_comments_per_post: z.number().int().min(1).max(1000).optional()
-    .describe('Max comments per post when type=comments.'),
+  max_comments: z.number().int().min(0).max(1000).optional()
+    .describe('Max comments to fetch per post. Set 0 to skip comments.'),
   include_comments: z.boolean().optional()
     .describe('Include comments alongside posts.'),
+  post_date_limit: z.string().optional()
+    .describe('Only return posts published on or after this date (ISO 8601, e.g. "2025-01-01").'),
+  comment_date_limit: z.string().optional()
+    .describe('Only return comments published on or after this date (ISO 8601, e.g. "2025-01-01").'),
   use_providers: z.array(z.string()).optional().describe(`Optional ordered list of providers to use. Leave empty to let ColdIQ automatically pick the best tool for your inputs — recommended for most use cases. Available providers: ${getProvidersForCapability('search_reddit').join(', ')}. Provider names are matched fuzzily, so minor typos are tolerated.`),
 }
 

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

@@ -309,6 +309,72 @@ describe('signalbase-job-change', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// theirstack-intent-discovery
+// ---------------------------------------------------------------------------
+
+describe('theirstack-intent-discovery', () => {
+  const p = () => get('theirstack-intent-discovery')
+
+  it('routes to the company search endpoint', () => {
+    expect(p().endpoint).toBe('/theirstack/companies/search')
+    expect(p().method).toBe('POST')
+  })
+
+  it('isApplicable: true for intent with topics and no companies/domains', () => {
+    expect(p().isApplicable!({ signal_type: 'intent', topics: ['sales-automation'] })).toBe(true)
+  })
+
+  it('isApplicable: false when companies present (verify mode handles that)', () => {
+    expect(p().isApplicable!({ signal_type: 'intent', topics: ['sales-automation'], companies: ['ColdIQ'] })).toBe(false)
+  })
+
+  it('isApplicable: false when domains present', () => {
+    expect(p().isApplicable!({ signal_type: 'intent', topics: ['sales-automation'], domains: ['coldiq.com'] })).toBe(false)
+  })
+
+  it('isApplicable: false when no topics', () => {
+    expect(p().isApplicable!({ signal_type: 'intent' })).toBe(false)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'funding', topics: ['x'] })).toBe(false)
+  })
+
+  it('mapParams forwards topics as company_keyword_slug_or', () => {
+    const result = p().mapParams({ signal_type: 'intent', topics: ['sales-automation', 'lead-generation'], limit: 20 })
+    const body = result.body as Record<string, unknown>
+    expect(body.company_keyword_slug_or).toEqual(['sales-automation', 'lead-generation'])
+    expect(body.limit).toBe(20)
+    expect(body.include_total_results).toBe(true)
+  })
+
+  it('mapParams forwards industries and countries when present', () => {
+    const result = p().mapParams({
+      signal_type: 'intent',
+      topics: ['sales-automation'],
+      industries: ['Software'],
+      countries: ['US', 'GB'],
+    })
+    const body = result.body as Record<string, unknown>
+    expect(body.industry_or).toEqual(['Software'])
+    expect(body.company_country_code_or).toEqual(['US', 'GB'])
+  })
+
+  it('mapParams caps limit at 100', () => {
+    const result = p().mapParams({ signal_type: 'intent', topics: ['x'], limit: 999 })
+    expect((result.body as Record<string, unknown>).limit).toBe(100)
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ name: 'ColdIQ' }] })).toBe(true)
+  })
+
+  it('hasResult: false on empty data', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // theirstack-buying-intents
 // ---------------------------------------------------------------------------

package/tests/registry.test.ts

@@ -1936,11 +1936,11 @@ describe('registry', () => {
       expect(() => r.async!.extractId({})).toThrow('no jobId')
     })
 
-    it('reddit.isApplicable: true only when start_urls is non-empty; query alone is not sufficient', () => {
+    it('reddit.isApplicable: true when start_urls is non-empty or a query string is provided', () => {
       const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
       expect(r.isApplicable!({ start_urls: ['https://reddit.com/r/sales/'] })).toBe(true)
       expect(r.isApplicable!({ query: 'x', start_urls: ['https://reddit.com/r/sales/'] })).toBe(true)
-      expect(r.isApplicable!({ query: 'B2B sales' })).toBe(false)
+      expect(r.isApplicable!({ query: 'B2B sales' })).toBe(true)
       expect(r.isApplicable!({})).toBe(false)
       expect(r.isApplicable!({ start_urls: [] })).toBe(false)
     })
@@ -1949,18 +1949,32 @@ describe('registry', () => {
       const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
       const out = r.mapParams({
         query: 'best CRM',
-        type: 'posts',
+        search_type: 'communities',
+        search_community_name: 'sales',
         sort: 'top',
         time: 'month',
         limit: 10,
         include_comments: true,
+        max_comments: 5,
+        post_date_limit: '2025-01-01',
+        comment_date_limit: '2025-02-01',
       }).body as Record<string, unknown>
       expect(out.searchQueries).toEqual(['best CRM'])
-      expect(out.type).toBe('posts')
+      expect(out.searchType).toBe('communities')
+      expect(out.searchCommunityName).toBe('sales')
       expect(out.sort).toBe('top')
       expect(out.time).toBe('month')
       expect(out.maxItems).toBe(10)
       expect(out.includeComments).toBe(true)
+      expect(out.maxComments).toBe(5)
+      expect(out.postDateLimit).toBe('2025-01-01')
+      expect(out.commentDateLimit).toBe('2025-02-01')
+    })
+
+    it('reddit.mapParams: defaults searchType to posts', () => {
+      const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+      const out = r.mapParams({ query: 'x' }).body as Record<string, unknown>
+      expect(out.searchType).toBe('posts')
     })
 
     it('reddit.mapParams: clamps maxItems to [1,200]', () => {

package/tests/tools/extract-post-engagement.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { extractPostEngagementHandler } from '../../src/tools/extract-post-engagement.js'
+
+const POST_URL = 'https://www.linkedin.com/feed/update/urn:li:activity:7234567890123456789'
+
+function res(body: unknown, status = 200, headers?: Record<string, string>) {
+  return new Response(JSON.stringify(body), { status, headers })
+}
+
+describe('extract_post_engagement handler', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+    vi.stubEnv('COLDIQ_ENGAGEMENT_POLL_MS', '1')
+    vi.stubEnv('COLDIQ_ENGAGEMENT_TIMEOUT_MS', '5000')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.unstubAllEnvs()
+  })
+
+  it('runs create → poll → fetch contacts and returns the people', async () => {
+    const people = [{ name: 'Alex Vacca', profile_url: 'https://www.linkedin.com/in/alexvacca' }]
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/workbooks/wb_1/contacts')) return res(people)
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'success', workbook_id: 'wb_1' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' }, 200, { 'x-coldiq-credits-charged': '10', 'x-coldiq-credits-remaining': '90' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    const parsed = JSON.parse(result.content[0].text)
+    expect(result.isError).toBeUndefined()
+    expect(parsed.data.people).toEqual(people)
+    expect(parsed.data.type).toBe('both')
+    expect(parsed._meta.credits_charged).toBe(10)
+  })
+
+  it('passes activity_filter=commenters when type=comments', async () => {
+    let contactsUrl = ''
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/workbooks/wb_1/contacts')) { contactsUrl = u; return res([]) }
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'success', workbook_id: 'wb_1' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    await extractPostEngagementHandler({ post_url: POST_URL, type: 'comments' })
+    expect(contactsUrl).toContain('activity_filter=commenters')
+  })
+
+  it('returns an error when the task fails upstream', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'failure' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    expect(result.isError).toBe(true)
+    expect(JSON.parse(result.content[0].text).error).toMatch(/extraction failed/i)
+  })
+
+  it('surfaces the create error when the job cannot start', async () => {
+    globalThis.fetch = vi.fn(async () => res({ error: 'Invalid LinkedIn post URL' }, 400)) as typeof fetch
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    expect(result.isError).toBe(true)
+    expect(JSON.parse(result.content[0].text).error).toMatch(/Invalid LinkedIn post URL/)
+  })
+})

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

@@ -139,14 +139,17 @@ describe('find_signals handler — hiring industries post-filter', () => {
     expect(body.data.data.map((r: { id: string }) => r.id)).toEqual(['a', 'c'])
   })
 
-  it('returns empty array when no row matches any industry', async () => {
+  it('returns unfiltered rows with a note when no row matches any industry', async () => {
     vi.mocked(mockedExecute).mockResolvedValueOnce({
       data: { success: true, data: [...hiringRows] },
       _meta: { provider: 'signalbase-hiring', latencyMs: 1 },
     })
     const result = await findSignalsHandler({ signal_type: 'hiring', industries: ['Aerospace'], limit: 25 })
     const body = JSON.parse(result.content[0].text)
-    expect(body.data.data).toEqual([])
+    // Non-destructive: keep all rows rather than return a misleading empty set,
+    // and flag that the industry filter matched nothing.
+    expect(body.data.data).toHaveLength(5)
+    expect(body.data._industry_filter).toMatch(/UNFILTERED/)
   })
 
   it('leaves rows untouched when industries is absent', async () => {

package/tests/tools/get-place-reviews.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { getPlaceReviewsHandler } from '../../src/tools/get-place-reviews.js'
+import { getProviders } from '../../src/registry.js'
+
+const PLACE_URL = 'https://www.google.com/maps/place/ColdIQ'
+
+describe('get_place_reviews handler', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  function withFastPolling<T>(fn: () => Promise<T>): Promise<T> {
+    const p = getProviders('get_place_reviews').find((x) => x.id === 'google_maps_reviews')!
+    const orig = { t: p.async!.timeoutMs, i: p.async!.pollIntervalMs }
+    p.async!.timeoutMs = 500
+    p.async!.pollIntervalMs = 20
+    return fn().finally(() => {
+      p.async!.timeoutMs = orig.t
+      p.async!.pollIntervalMs = orig.i
+    })
+  }
+
+  it('submits the reviews job and returns reviews when done', async () => {
+    const reviews = [{ text: 'Great service', stars: 5 }]
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/google-maps/reviews/rev-1')) {
+        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'done', reviews }), { status: 200 })
+      }
+      if (u.includes('/google-maps/reviews')) {
+        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'processing' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await withFastPolling(() =>
+      getPlaceReviewsHandler({ place_urls: [PLACE_URL], max_reviews: 10, sort: 'lowestRanking' }),
+    )
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('google_maps_reviews')
+    expect(parsed.data.reviews).toEqual(reviews)
+  })
+
+  it('forwards place_urls, max_reviews and sort to the upstream body', async () => {
+    let submitBody: Record<string, unknown> = {}
+    globalThis.fetch = vi.fn(async (url: string | URL, init?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/google-maps/reviews/rev-1')) {
+        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'done', reviews: [] }), { status: 200 })
+      }
+      if (u.includes('/google-maps/reviews')) {
+        submitBody = JSON.parse(init!.body as string)
+        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'processing' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    await withFastPolling(() =>
+      getPlaceReviewsHandler({ place_urls: [PLACE_URL], max_reviews: 25, sort: 'newest' }),
+    )
+    expect(submitBody.startUrls).toEqual([{ url: PLACE_URL }])
+    expect(submitBody.maxReviews).toBe(25)
+    expect(submitBody.reviewsSort).toBe('newest')
+  })
+})

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

@@ -122,4 +122,73 @@ describe('search_reddit handler', () => {
       reddit.async!.pollIntervalMs = orig.i
     }
   })
+
+  it('rewrites a bare subreddit URL + query into an in-subreddit search URL', async () => {
+    let capturedBody: Record<string, unknown> | null = null
+    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/reddit/scrape') && !u.includes('/scrape/')) {
+        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
+        return new Response(JSON.stringify({ jobId: 'r-4' }), { status: 200 })
+      }
+      if (u.includes('/reddit/scrape/r-4')) {
+        return new Response(JSON.stringify({ jobId: 'r-4', status: 'done', items: [{ title: 'lemlist review' }] }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const { getProviders } = await import('../../src/registry.js')
+    const reddit = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+    const orig = { t: reddit.async!.timeoutMs, i: reddit.async!.pollIntervalMs }
+    try {
+      reddit.async!.timeoutMs = 500
+      reddit.async!.pollIntervalMs = 20
+      await searchRedditHandler({
+        start_urls: ['https://www.reddit.com/r/coldemail/'],
+        query: 'lemlist',
+        time: 'month',
+        limit: 5,
+      })
+      const urls = (capturedBody!.startUrls as Array<{ url: string }>).map((s) => s.url)
+      expect(urls[0]).toContain('/r/coldemail/search/')
+      expect(urls[0]).toContain('q=lemlist')
+      expect(urls[0]).toContain('restrict_sr=1')
+      expect(urls[0]).toContain('t=month')
+      // Query now lives in the URL — top-level searchQueries is dropped to avoid a global search.
+      expect(capturedBody!.searchQueries).toBeUndefined()
+    } finally {
+      reddit.async!.timeoutMs = orig.t
+      reddit.async!.pollIntervalMs = orig.i
+    }
+  })
+
+  it('leaves an existing search URL untouched and keeps it as the start url', async () => {
+    let capturedBody: Record<string, unknown> | null = null
+    const searchUrl = 'https://www.reddit.com/search/?q=lemlist&sort=new'
+    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/reddit/scrape') && !u.includes('/scrape/')) {
+        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
+        return new Response(JSON.stringify({ jobId: 'r-5' }), { status: 200 })
+      }
+      if (u.includes('/reddit/scrape/r-5')) {
+        return new Response(JSON.stringify({ jobId: 'r-5', status: 'done', items: [{ title: 'x' }] }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const { getProviders } = await import('../../src/registry.js')
+    const reddit = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+    const orig = { t: reddit.async!.timeoutMs, i: reddit.async!.pollIntervalMs }
+    try {
+      reddit.async!.timeoutMs = 500
+      reddit.async!.pollIntervalMs = 20
+      await searchRedditHandler({ start_urls: [searchUrl], query: 'lemlist', limit: 5 })
+      const urls = (capturedBody!.startUrls as Array<{ url: string }>).map((s) => s.url)
+      expect(urls[0]).toBe(searchUrl)
+    } finally {
+      reddit.async!.timeoutMs = orig.t
+      reddit.async!.pollIntervalMs = orig.i
+    }
+  })
 })