@adrata/adrata-mcp 1.0.0

package/toolsets/prospecting.js

@@ -0,0 +1,314 @@
+/**
+ * Prospecting Toolset (6 tools, Pro tier)
+ *
+ * qualify_company, research_company, research_person,
+ * get_priority_pursuits, get_speedrun_list (legacy alias), discover_prospects,
+ * get_next_contacts
+ */
+
+import { z } from 'zod';
+import {
+  md, mdError,
+  formatQualification, formatCompanyResearch, formatPersonResearch,
+  formatSpeedrunList, formatNextContacts, table, signalEmoji, formatDate, daysSince,
+} from '../output-formatter.js';
+
+export function register(server, api, AUTH) {
+
+  // -----------------------------------------------------------------------
+  // qualify_company
+  // -----------------------------------------------------------------------
+  server.tool(
+    'qualify_company',
+    'Qualify a company against your ICP Matrix. Returns a coaching narrative with score, intent signals, deal authority, and recommended next move. Orchestrates 4+ API calls into one result.',
+    {
+      companyId: z.string().optional().describe('Company ID (if known)'),
+      name: z.string().optional().describe('Company name (used to search if no ID)'),
+    },
+    async (args) => {
+      try {
+        // Resolve company
+        let companyId = args.companyId;
+        let company;
+
+        if (!companyId && args.name) {
+          const search = await api('GET', '/api/v1/companies', { params: { search: args.name, limit: 3, page: 1 } });
+          const match = (search?.data || [])[0];
+          if (!match) return mdError(`Company "${args.name}" not found`, 'Try a different name or create the company first.');
+          companyId = match.id;
+          company = match;
+        } else if (companyId) {
+          company = await api('GET', `/api/v1/companies/${companyId}`);
+          company = company?.data || company;
+        } else {
+          return mdError('Provide companyId or name');
+        }
+
+        // Parallel: ICP score, signals, authority
+        const [icpScore, signals, authority] = await Promise.all([
+          api('POST', `/api/v1/icp-scoring/score-company/${encodeURIComponent(companyId)}`, { body: {} }).catch(() => ({ score: 0 })),
+          api('GET', '/api/v1/intent-signals', { params: { companyId } }).catch(() => ({ data: [] })),
+          api('GET', '/api/v1/deal-authority/buyer-intelligence', { params: { opportunityId: companyId } }).catch(() => ({})),
+        ]);
+
+        return md(formatQualification(company, icpScore, signals, authority));
+      } catch (err) {
+        return mdError('Qualification failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // research_company
+  // -----------------------------------------------------------------------
+  server.tool(
+    'research_company',
+    'Deep research report on a company: firmographics, tech stack, funding, news, competitors, intent signals. Orchestrates 5+ API calls into a structured report.',
+    {
+      companyId: z.string().optional().describe('Company ID'),
+      name: z.string().optional().describe('Company name to search'),
+    },
+    async (args) => {
+      try {
+        let companyId = args.companyId;
+        let company;
+
+        if (!companyId && args.name) {
+          const search = await api('GET', '/api/v1/companies', { params: { search: args.name, limit: 3, page: 1 } });
+          const match = (search?.data || [])[0];
+          if (!match) return mdError(`Company "${args.name}" not found`);
+          companyId = match.id;
+          company = match;
+        } else if (companyId) {
+          company = await api('GET', `/api/v1/companies/${companyId}`);
+          company = company?.data || company;
+        } else {
+          return mdError('Provide companyId or name');
+        }
+
+        // Parallel enrichment
+        const [enrichment, signals, competitors] = await Promise.all([
+          api('POST', `/api/v1/companies/${companyId}/enrich`).catch(() => ({})),
+          api('GET', '/api/v1/intent-signals', { params: { companyId } }).catch(() => ({ data: [] })),
+          api('GET', '/api/v1/competitors', { params: { companyId } }).catch(() => ({ data: [] })),
+        ]);
+
+        return md(formatCompanyResearch(company, enrichment, signals, competitors));
+      } catch (err) {
+        return mdError('Research failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // research_person
+  // -----------------------------------------------------------------------
+  server.tool(
+    'research_person',
+    'Deep research on a person: professional profile, communication preferences, intro paths, recent activity. Orchestrates 3+ API calls.',
+    {
+      personId: z.string().optional().describe('Person ID'),
+      name: z.string().optional().describe('Person name to search'),
+      email: z.string().optional().describe('Email to search by'),
+    },
+    async (args) => {
+      try {
+        let personId = args.personId;
+        let person;
+
+        if (!personId && (args.name || args.email)) {
+          const q = args.email || args.name;
+          const search = await api('GET', '/api/v1/people', { params: { search: q, limit: 5, page: 1 } });
+          const match = args.email
+            ? (search?.data || []).find(p => p.email?.toLowerCase() === args.email.toLowerCase()) || (search?.data || [])[0]
+            : (search?.data || [])[0];
+          if (!match) return mdError(`Person not found: "${q}"`);
+          personId = match.id;
+          person = match;
+        } else if (personId) {
+          person = await api('GET', `/api/v1/people/${personId}`);
+          person = person?.data || person;
+        } else {
+          return mdError('Provide personId, name, or email');
+        }
+
+        // Parallel: enrichment + actions
+        const [enrichment, actions] = await Promise.all([
+          api('POST', `/api/v1/people/${personId}/enrich`).catch(() => ({})),
+          api('GET', '/api/v1/actions', { params: { personId, limit: 10, page: 1 } }).catch(() => ({ data: [] })),
+        ]);
+
+        return md(formatPersonResearch(person, enrichment, actions));
+      } catch (err) {
+        return mdError('Research failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_priority_pursuits
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_priority_pursuits',
+    'Get today\'s evidence-ranked Priority Pursuits with coaching context. Each item includes the person, company, signal score, and recommended next move.',
+    {
+      limit: z.number().optional().describe('Number of items (default 25)'),
+    },
+    async (args) => {
+      try {
+        const data = await api('GET', '/api/v1/speedrun', { params: { limit: args.limit || 25, page: 1 } });
+        return md(formatSpeedrunList(data));
+      } catch (err) {
+        return mdError('Could not load Priority Pursuits', err.message);
+      }
+    }
+  );
+
+  // Compatibility alias for clients that have not refreshed their tool list.
+  server.tool(
+    'get_speedrun_list',
+    'Legacy alias for get_priority_pursuits.',
+    {
+      limit: z.number().optional().describe('Number of items (default 25)'),
+    },
+    async (args) => {
+      try {
+        const data = await api('GET', '/api/v1/speedrun', { params: { limit: args.limit || 25, page: 1 } });
+        return md(formatSpeedrunList(data));
+      } catch (err) {
+        return mdError('Could not load Priority Pursuits', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // discover_prospects
+  // -----------------------------------------------------------------------
+  server.tool(
+    'discover_prospects',
+    'Find companies or people matching criteria. Search by industry, size, technology, title, or keywords. Returns qualified matches with ICP Matrix scores.',
+    {
+      type: z.enum(['companies', 'people']).optional().describe('Search for companies or people (default: companies)'),
+      industry: z.string().optional().describe('Industry filter'),
+      size: z.string().optional().describe('Company size filter (e.g. "100-500")'),
+      title: z.string().optional().describe('Job title filter (people search)'),
+      keywords: z.string().optional().describe('Free-text search keywords'),
+      limit: z.number().optional().describe('Max results (default 25)'),
+    },
+    async (args) => {
+      try {
+        const type = args.type || 'companies';
+        const endpoint = type === 'people' ? '/api/v1/people' : '/api/v1/companies';
+        const params = {
+          search: args.keywords,
+          industry: args.industry,
+          limit: args.limit || 25,
+          page: 1,
+        };
+        if (args.title) params.title = args.title;
+        if (args.size) params.size = args.size;
+
+        const data = await api('GET', endpoint, { params });
+        const items = data?.data || [];
+
+        if (items.length === 0) {
+          return md(`## Prospect Discovery\n\nNo ${type} found matching your criteria. Try broadening your search.\n`);
+        }
+
+        let text = `## Prospect Discovery \u2014 ${items.length} ${type}\n\n`;
+
+        if (type === 'companies') {
+          const rows = items.map((c, i) => [
+            String(i + 1),
+            c.name || '\u2014',
+            c.industry || '\u2014',
+            c.employeeCount || c.size || '\u2014',
+            c.status || '\u2014',
+          ]);
+          text += table(['#', 'Company', 'Industry', 'Size', 'Status'], rows);
+        } else {
+          const rows = items.map((p, i) => [
+            String(i + 1),
+            p.name || `${p.firstName} ${p.lastName}`,
+            p.title || '\u2014',
+            p.companyName || '\u2014',
+            p.email || '\u2014',
+          ]);
+          text += table(['#', 'Name', 'Title', 'Company', 'Email'], rows);
+        }
+
+        return md(text);
+      } catch (err) {
+        return mdError('Discovery failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_next_contacts
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_next_contacts',
+    'Who should I contact next? Returns a ranked list with last touch, days since touch, signal score, and recommended next move. Combines overdue tasks, stale contacts, and hot signals.',
+    {
+      limit: z.number().optional().describe('Max contacts to return (default 10)'),
+    },
+    async (args) => {
+      try {
+        const limit = args.limit || 10;
+
+        // Parallel: overdue actions, today's actions, speedrun list
+        const [overdue, today, speedrun] = await Promise.all([
+          api('GET', '/api/v1/actions/overdue', { params: { limit: 25, page: 1 } }).catch(() => ({ data: [] })),
+          api('GET', '/api/v1/actions/today', { params: { limit: 25, page: 1 } }).catch(() => ({ data: [] })),
+          api('GET', '/api/v1/speedrun', { params: { limit, page: 1 } }).catch(() => ({ data: [] })),
+        ]);
+
+        // Merge and deduplicate by personId
+        const seen = new Set();
+        const contacts = [];
+
+        // Priority Pursuit items first (already ranked)
+        for (const item of (speedrun?.data || [])) {
+          const key = item.personId || item.name;
+          if (!seen.has(key)) {
+            seen.add(key);
+            contacts.push({
+              name: item.personName || item.name,
+              companyName: item.companyName,
+              signal: item.reason || item.signal,
+              signalType: item.signalType || 'intent',
+              lastActionType: item.lastActionType,
+              lastActionDate: item.lastActionDate,
+              daysSinceTouch: item.lastActionDate ? daysSince(item.lastActionDate) : null,
+              nextAction: item.nextAction || 'Follow up',
+            });
+          }
+        }
+
+        // Add overdue actions
+        for (const action of (overdue?.data || [])) {
+          const key = action.personId || action.title;
+          if (!seen.has(key)) {
+            seen.add(key);
+            contacts.push({
+              name: action.personName || action.title,
+              companyName: action.companyName,
+              signal: 'Overdue task',
+              signalType: 'intent',
+              lastActionType: action.type,
+              lastActionDate: action.dueDate,
+              daysSinceTouch: action.dueDate ? daysSince(action.dueDate) : null,
+              nextAction: action.title,
+            });
+          }
+        }
+
+        const overdueCount = (overdue?.data || []).length;
+        return md(formatNextContacts(contacts.slice(0, limit), overdueCount, 0));
+      } catch (err) {
+        return mdError('Could not load next contacts', err.message);
+      }
+    }
+  );
+}

package/toolsets/revenue/always-loaded.js

@@ -0,0 +1,341 @@
+/**
+ * Always-Loaded Toolset (6 tools)
+ *
+ * These tools are registered at startup and always available in context.
+ * They include toolset discovery, free-tier search, and inbox check.
+ */
+
+import { z } from 'zod';
+import { md, mdError, formatInbox } from '../../output-formatter.js';
+import { getDemoAvailability } from '../../tools/scheduling.js';
+
+export const TOOLSET_REGISTRY = {
+  prospecting: {
+    name: 'prospecting',
+    description: 'Qualify companies, research prospects, get daily priorities, discover leads',
+    tier: 'pro',
+    toolCount: 6,
+  },
+  intelligence: {
+    name: 'intelligence',
+    description: 'Competitive intel, meeting briefs, deal coaching, signals, forecasting',
+    tier: 'pro',
+    toolCount: 5,
+  },
+  outreach: {
+    name: 'outreach',
+    description: 'Draft/send emails, manage sequences, analytics, network paths, search emails',
+    tier: 'pro',
+    toolCount: 8,
+  },
+  crm: {
+    name: 'crm',
+    description:
+      'Full CRUD (create, read, update, delete) for companies, people, opportunities, activities, and buyer groups — including deleting a buyer room and its members',
+    tier: 'enterprise',
+    toolCount: 6,
+  },
+  communications: {
+    name: 'communications',
+    description: 'Phone calls, SMS, call transcripts, calendar, meeting scheduling',
+    tier: 'enterprise',
+    toolCount: 5,
+  },
+  infrastructure: {
+    name: 'infrastructure',
+    description: 'Domains, mailboxes, deliverability, OAuth providers, workspace, data management',
+    tier: 'enterprise',
+    toolCount: 6,
+  },
+  knowledge: {
+    name: 'knowledge',
+    description:
+      'Search wiki pages, account wikis, create battle cards/playbooks, link files to CRM records',
+    tier: 'pro',
+    toolCount: 4,
+  },
+  matrix: {
+    name: 'matrix',
+    description:
+      'Ask Matrix analytics, inspect forecast risk, review anomalies, and turn GTM intelligence into action',
+    tier: 'pro',
+    toolCount: 25,
+  },
+};
+
+export function register(server, api, AUTH) {
+  // -----------------------------------------------------------------------
+  // list_toolsets -- discover available toolset groups
+  // -----------------------------------------------------------------------
+  server.tool(
+    'list_toolsets',
+    'List available composite toolsets. Each toolset contains multiple high-level tools. Use enable_toolset to load one into your session. Only toolsets your tier can access are shown.',
+    {},
+    async () => {
+      const tierRank = { free: 0, pro: 1, enterprise: 2 };
+      const userRank = tierRank[AUTH.tier] ?? 0;
+
+      const rows = [];
+      for (const ts of Object.values(TOOLSET_REGISTRY)) {
+        const accessible = tierRank[ts.tier] <= userRank;
+        rows.push([
+          ts.name,
+          `${ts.toolCount} tools`,
+          ts.description,
+          accessible ? '\u2705' : `\uD83D\uDD12 ${ts.tier}`,
+        ]);
+      }
+
+      let text = '## Available Toolsets\n\n';
+      text += '| Toolset | Tools | Description | Access |\n';
+      text += '|---------|-------|-------------|--------|\n';
+      rows.forEach((r) => {
+        text += `| ${r.join(' | ')} |\n`;
+      });
+      text += '\nUse `enable_toolset` with the toolset name to load its tools.\n';
+      return md(text);
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // enable_toolset -- load a toolset's tools into the session
+  // -----------------------------------------------------------------------
+  server.tool(
+    'enable_toolset',
+    "Load a toolset into the current session. This registers all tools in the named toolset so you can call them. Use list_toolsets first to see what's available.",
+    {
+      name: z
+        .string()
+        .describe(
+          'Toolset name: prospecting, intelligence, outreach, crm, communications, infrastructure, knowledge, matrix'
+        ),
+    },
+    async (args) => {
+      const ts = TOOLSET_REGISTRY[args.name];
+      if (!ts) {
+        return mdError(
+          `Unknown toolset: "${args.name}"`,
+          `Available toolsets: ${Object.keys(TOOLSET_REGISTRY).join(', ')}`
+        );
+      }
+
+      const tierRank = { free: 0, pro: 1, enterprise: 2 };
+      if ((tierRank[ts.tier] ?? 0) > (tierRank[AUTH.tier] ?? 0)) {
+        return mdError(
+          `Toolset "${args.name}" requires ${ts.tier} tier.`,
+          `Your current tier is ${AUTH.tier}. Use connect_workspace or upgrade_account to access higher tiers.`
+        );
+      }
+
+      // Check if already loaded
+      if (ts._loaded) {
+        return md(`## ${ts.name}\n\nAlready loaded. ${ts.toolCount} tools available.\n`);
+      }
+
+      // Dynamically import and register.
+      // The toolset modules live in code/mcp/toolsets/, one level UP from this
+      // file's own directory (code/mcp/toolsets/revenue/). PR #502 moved this
+      // file into revenue/ without updating the specifier, which left every
+      // toolset permanently unloadable ("Cannot find module .../revenue/crm.js").
+      try {
+        const module = await import(`../${ts.name}.js`);
+        const skipped = [];
+        const realTool = server.tool.bind(server);
+        const dedupingServer = Object.create(server);
+        dedupingServer.tool = (name, ...rest) => {
+          try {
+            return realTool(name, ...rest);
+          } catch (err) {
+            if (/already registered/i.test(String(err?.message || err))) {
+              skipped.push(name);
+              return undefined;
+            }
+            throw err;
+          }
+        };
+        module.register(dedupingServer, api, AUTH);
+        ts._loaded = true;
+
+        return md(
+          `## ${ts.name} \u2014 Loaded\n\n${ts.toolCount} tools now available. ${ts.description}.\n`
+        );
+      } catch (err) {
+        return mdError(`Failed to load toolset "${args.name}": ${err.message}`);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // find_company -- Claude-powered free search (delegates to free-search.js)
+  // -----------------------------------------------------------------------
+  // Note: find_company and find_person are already registered in server.js
+  // as free-tier tools. We don't re-register them here to avoid conflicts.
+  // They are always available by default.
+
+  // -----------------------------------------------------------------------
+  // get_demo_availability -- free tier scheduling via Cal.com
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_demo_availability',
+    'Check available demo time slots from Cal.com. Returns the next 5 available slots for scheduling a product demo. Free tier — no account needed. Falls back to a booking link if Cal.com API is unavailable.',
+    {
+      timezone: z
+        .string()
+        .optional()
+        .describe('IANA timezone (e.g. "America/New_York"). Auto-detected if omitted.'),
+    },
+    async (args) => {
+      try {
+        const result = await getDemoAvailability(args.timezone);
+
+        if (result.fallback) {
+          let text = '## Demo Availability\n\n';
+          text += result.message + '\n';
+          return md(text);
+        }
+
+        let text = '## Demo Availability\n\n';
+        const rows = result.slots.map((s, i) => [
+          `${i + 1}`,
+          s.date || '\u2014',
+          s.time || '\u2014',
+          s.duration || '30 min',
+        ]);
+        text += `Timezone: ${result.timezone}\n\n`;
+        text += '| # | Date | Time | Duration |\n|---|------|------|----------|\n';
+        rows.forEach((r) => {
+          text += `| ${r.join(' | ')} |\n`;
+        });
+        text += '\nUse `schedule_demo` with a date and time to book.\n';
+        return md(text);
+      } catch (err) {
+        return mdError('Could not fetch demo availability', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // check_inbox -- cross-references replies with CRM + sequences
+  // -----------------------------------------------------------------------
+  server.tool(
+    'check_inbox',
+    'Check your inbox for new replies. Cross-references with CRM contacts and active sequences to classify reply types (positive, OOO, meeting request, not interested) and suggest Next Moves. The "Did anyone get back to me?" tool.',
+    {
+      since: z
+        .string()
+        .optional()
+        .describe('Check replies since date (ISO string, default: yesterday)'),
+    },
+    async (args) => {
+      try {
+        // An empty email feed is not evidence of zero replies when no inbox has been connected.
+        // Check coverage first so Adrata never reports a false all-clear.
+        const providerResponse = await api('GET', '/api/v1/oauth/email/providers');
+        const providers = Array.isArray(providerResponse?.data)
+          ? providerResponse.data
+          : Array.isArray(providerResponse)
+            ? providerResponse
+            : [];
+        const connectedProviders = providers.filter(
+          (provider) =>
+            provider && provider.status !== 'disconnected' && provider.status !== 'revoked'
+        );
+        if (connectedProviders.length === 0) {
+          return md(
+            '## Inbox not connected\n\n' +
+              'Adrata cannot check replies yet because this workspace has no connected Google or Microsoft inbox. ' +
+              'Connect an inbox in Desktop → Settings → Connections, wait for the first sync to succeed, then run `check_inbox` again.\n'
+          );
+        }
+
+        // Fetch recent emails
+        const since = args.since || new Date(Date.now() - 86400000).toISOString();
+        const emails = await api('GET', '/api/v1/emails', {
+          params: { folder: 'inbox', since, limit: 50, page: 1 },
+        });
+        const replies = (emails?.data || []).filter(
+          (e) => e.isReply || e.inReplyTo || (e.subject && e.subject.startsWith('Re:'))
+        );
+
+        if (replies.length === 0) {
+          return md(
+            '## Inbox\n\nNo new replies were found in the connected inboxes for this period.\n'
+          );
+        }
+
+        // Enrich with CRM data where possible
+        const enriched = await Promise.all(
+          replies.slice(0, 15).map(async (email) => {
+            let companyName = email.companyName || '';
+            let replyType = 'unknown';
+            let suggestedAction = '';
+
+            // Try to classify reply
+            const bodyLower = (email.body || email.snippet || '').toLowerCase();
+            if (
+              bodyLower.includes('out of office') ||
+              bodyLower.includes('ooo') ||
+              bodyLower.includes('vacation')
+            ) {
+              replyType = 'ooo';
+              suggestedAction = 'Paused \u2014 follow up when back';
+            } else if (
+              bodyLower.includes('not interested') ||
+              bodyLower.includes('unsubscribe') ||
+              bodyLower.includes('remove me')
+            ) {
+              replyType = 'not_interested';
+              suggestedAction = 'Debrief and update status';
+            } else if (
+              bodyLower.includes('meeting') ||
+              bodyLower.includes('schedule') ||
+              bodyLower.includes('calendar') ||
+              bodyLower.includes('call')
+            ) {
+              replyType = 'meeting_request';
+              suggestedAction = 'Confirm meeting time';
+            } else if (
+              bodyLower.includes('interest') ||
+              bodyLower.includes('tell me more') ||
+              bodyLower.includes('sounds good') ||
+              bodyLower.includes('yes')
+            ) {
+              replyType = 'positive';
+              suggestedAction = 'Book meeting';
+            } else if (bodyLower.includes('?')) {
+              replyType = 'question';
+              suggestedAction = 'Answer question';
+            }
+
+            // Try to find company from sender
+            if (!companyName && email.from) {
+              const domain = email.from.split('@')[1];
+              if (domain) {
+                try {
+                  const search = await api('GET', '/api/v1/companies', {
+                    params: { search: domain, limit: 1, page: 1 },
+                  });
+                  if (search?.data?.[0]) companyName = search.data[0].name;
+                } catch {
+                  /* ignore */
+                }
+              }
+            }
+
+            return {
+              from: email.from || email.sender,
+              company: companyName,
+              subject: email.subject,
+              replyType,
+              suggestedAction,
+            };
+          })
+        );
+
+        return md(formatInbox(enriched));
+      } catch (err) {
+        return mdError('Could not check inbox', err.message);
+      }
+    }
+  );
+}