@adrata/adrata-mcp 1.0.0

package/toolsets/intelligence.js

@@ -0,0 +1,232 @@
+/**
+ * Intelligence Toolset (5 tools, Pro tier)
+ *
+ * get_competitive_intel, get_meeting_brief, get_deal_coaching,
+ * get_signals_dashboard, get_forecast
+ */
+
+import { z } from 'zod';
+import {
+  md, mdError,
+  formatCompetitiveIntel, formatMeetingBrief, formatDealCoaching,
+  formatSignalsDashboard, formatForecast,
+} from '../output-formatter.js';
+
+export function register(server, api, AUTH) {
+
+  // -----------------------------------------------------------------------
+  // get_competitive_intel
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_competitive_intel',
+    'Get competitive intelligence for a company: battlecard positioning, competitor strengths/weaknesses, recent competitive moves, and displacement strategies.',
+    {
+      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');
+        }
+
+        const competitors = await api('GET', '/api/v1/competitors', { params: { companyId } }).catch(() => ({ data: [] }));
+        return md(formatCompetitiveIntel(company, competitors));
+      } catch (err) {
+        return mdError('Competitive intel failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_meeting_brief
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_meeting_brief',
+    'Generate a pre-meeting intelligence brief: attendee profiles, company context, recent signals, talking points, and suggested agenda. Walk into every meeting prepared.',
+    {
+      meetingId: z.string().optional().describe('Meeting ID for a specific meeting'),
+      companyId: z.string().optional().describe('Company ID for ad-hoc brief'),
+      personIds: z.array(z.string()).optional().describe('Person IDs of attendees'),
+    },
+    async (args) => {
+      try {
+        let meeting = {};
+        let attendees = [];
+        let companyIntel = null;
+
+        if (args.meetingId) {
+          // Base record is the calendar event (real attendees + timing); the
+          // copilot summary/action-items only exist for recorded meetings, so
+          // they stay best-effort and degrade to empty for plain calendar events.
+          meeting = await api('GET', `/api/v1/events/${args.meetingId}`).catch(() => ({}));
+          meeting = meeting?.data || meeting;
+
+          // Get action items and summary
+          const [summary, actionItems] = await Promise.all([
+            api('GET', `/api/v1/meetings/${args.meetingId}/summary`).catch(() => ({})),
+            api('GET', `/api/v1/meetings/${args.meetingId}/action-items`).catch(() => ({ data: [] })),
+          ]);
+
+          if (summary?.data) meeting.summary = summary.data;
+          if (actionItems?.data) meeting.actionItems = actionItems.data;
+        }
+
+        // Resolve attendees
+        const personIds = args.personIds || meeting.attendeeIds || [];
+        if (personIds.length > 0) {
+          attendees = await Promise.all(
+            personIds.slice(0, 10).map(id =>
+              api('GET', `/api/v1/people/${id}`).then(r => r?.data || r).catch(() => ({ id }))
+            )
+          );
+        }
+
+        // Company intel
+        const companyId = args.companyId || meeting.companyId || attendees[0]?.companyId;
+        if (companyId) {
+          const [company, signals] = await Promise.all([
+            api('GET', `/api/v1/companies/${companyId}`).then(r => r?.data || r).catch(() => null),
+            api('GET', '/api/v1/intent-signals', { params: { companyId } }).catch(() => ({ data: [] })),
+          ]);
+
+          if (company) {
+            companyIntel = {
+              ...company,
+              recentSignals: signals?.data || [],
+            };
+          }
+        }
+
+        return md(formatMeetingBrief(meeting, attendees, companyIntel));
+      } catch (err) {
+        return mdError('Meeting brief failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_deal_coaching
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_deal_coaching',
+    'MEDDPIC analysis for a deal with risk assessment, forcing questions, and recommended next move. Orchestrates opportunity, stakeholder, and activity data into coaching insights.',
+    {
+      opportunityId: z.string().describe('Opportunity/deal ID'),
+    },
+    async (args) => {
+      try {
+        // Parallel: opportunity, authority, actions
+        const [opportunity, authority, actions] = await Promise.all([
+          api('GET', `/api/v1/opportunities/${args.opportunityId}`).then(r => r?.data || r),
+          api('GET', '/api/v1/deal-authority/buyer-intelligence', { params: { opportunityId: args.opportunityId } }).catch(() => ({})),
+          api('GET', '/api/v1/actions', { params: { companyId: args.opportunityId, limit: 20, page: 1 } }).catch(() => ({ data: [] })),
+        ]);
+
+        const authData = authority?.data || authority || {};
+        const actList = actions?.data || [];
+
+        // Build MEDDPIC analysis from available data
+        const analysis = {
+          meddpic: {
+            metrics: { score: opportunity.amount ? 7 : 3, detail: opportunity.amount ? `$${opportunity.amount.toLocaleString()} identified` : 'No metrics defined' },
+            economicBuyer: { score: authData.decisionMaker ? 8 : 3, detail: authData.decisionMaker || 'Not identified' },
+            decisionCriteria: { score: opportunity.stage === 'Qualification' || opportunity.stage === 'Proposal' ? 6 : 3, detail: opportunity.stage || 'Early stage' },
+            decisionProcess: { score: opportunity.probability ? Math.min(10, Math.round(opportunity.probability / 10)) : 3, detail: `${opportunity.probability || 0}% probability` },
+            identifyPain: { score: actList.length > 5 ? 7 : actList.length > 0 ? 5 : 2, detail: `${actList.length} interactions logged` },
+            champion: { score: authData.champion ? 9 : 2, detail: authData.champion || 'No champion identified' },
+          },
+          risks: [],
+          nextAction: '',
+        };
+
+        // Identify risks
+        if (!authData.champion) analysis.risks.push('No champion identified \u2014 deals without champions close at 10% rate');
+        if (!authData.decisionMaker) analysis.risks.push('Economic buyer unknown \u2014 you may be single-threaded');
+        if (opportunity.probability && opportunity.probability < 30) analysis.risks.push('Low probability \u2014 validate that the pain is real and urgent');
+        if (actList.length < 3) analysis.risks.push('Low activity \u2014 engagement may be stalling');
+
+        // Recommend next move
+        if (!authData.champion) {
+          analysis.nextAction = 'Find your champion. Ask: "Who else on your team would benefit from this?" Map the buying committee before advancing.';
+        } else if (!authData.decisionMaker) {
+          analysis.nextAction = 'Get to the economic buyer. Ask your champion: "Walk me through how budget decisions get made for initiatives like this."';
+        } else {
+          analysis.nextAction = 'Advance to next stage by confirming decision criteria and timeline with the economic buyer.';
+        }
+
+        return md(formatDealCoaching(opportunity, analysis));
+      } catch (err) {
+        return mdError('Deal coaching failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_signals_dashboard
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_signals_dashboard',
+    'Intent signals across all accounts, grouped by urgency. Shows buying signals, leadership changes, hiring patterns, funding events, and competitive moves.',
+    {
+      days: z.number().optional().describe('Lookback period in days (default 30)'),
+      companyId: z.string().optional().describe('Filter to a specific company'),
+    },
+    async (args) => {
+      try {
+        const params = { limit: 50, page: 1 };
+        if (args.companyId) params.companyId = args.companyId;
+        if (args.days) params.days = args.days;
+
+        const signals = await api('GET', '/api/v1/intent-signals', { params });
+        return md(formatSignalsDashboard(signals));
+      } catch (err) {
+        return mdError('Signals dashboard failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_forecast
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_forecast',
+    'Pipeline forecast with confidence intervals, stage breakdown, at-risk deals, and win rate trends. The executive-level view of your pipeline health.',
+    {
+      period: z.string().optional().describe('Forecast period: 7d, 30d, 90d, qtd, ytd (default: qtd)'),
+    },
+    async (args) => {
+      try {
+        const period = args.period || 'qtd';
+
+        // Parallel: forecast + pipeline metrics
+        const [forecast, pipeline] = await Promise.all([
+          api('GET', '/api/v1/forecast', { params: { period } }).catch(() => ({})),
+          api('GET', '/api/v1/analytics/pipeline', { params: { period } }).catch(() => ({})),
+        ]);
+
+        // Merge data
+        const merged = {
+          ...(forecast?.data || forecast || {}),
+          ...(pipeline?.data || pipeline || {}),
+        };
+
+        return md(formatForecast({ data: merged }));
+      } catch (err) {
+        return mdError('Forecast failed', err.message);
+      }
+    }
+  );
+}

package/toolsets/knowledge.js

@@ -0,0 +1,154 @@
+/**
+ * Knowledge Hub Toolset (4 tools, Pro tier)
+ *
+ * search_knowledge, get_account_wiki, create_knowledge_file, link_file_to_entity
+ */
+
+import { z } from 'zod';
+import { md, mdError, table } from '../output-formatter.js';
+
+export function register(server, api, AUTH) {
+
+  // -----------------------------------------------------------------------
+  // search_knowledge
+  // -----------------------------------------------------------------------
+  server.tool(
+    'search_knowledge',
+    'Search wiki pages and knowledge files (battle cards, playbooks, competitive intel). Returns matching content ranked by relevance.',
+    {
+      query: z.string().describe('Search query'),
+      pageType: z.string().optional().describe('Filter by page type (e.g. battlecard, playbook, overview)'),
+      limit: z.number().optional().describe('Max results (default 25)'),
+    },
+    async (args) => {
+      try {
+        const params = { q: args.query };
+        if (args.pageType) params.pageType = args.pageType;
+        if (args.limit) params.limit = args.limit;
+
+        const result = await api('GET', '/api/v1/knowledge/wiki/search', { params });
+        const items = result?.data || [];
+
+        if (items.length === 0) {
+          return md('## Knowledge Search\n\nNo results found.\n');
+        }
+
+        let text = `## Knowledge Search: "${args.query}"\n\n`;
+        const rows = items.map(item => [
+          item.title || '\u2014',
+          item.pageType || item.fileType || '\u2014',
+          item.category || '\u2014',
+          item.updatedAt ? new Date(item.updatedAt).toLocaleDateString() : '\u2014',
+        ]);
+        text += table(['Title', 'Type', 'Category', 'Updated'], rows);
+        return md(text);
+      } catch (err) {
+        return mdError('Knowledge search failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_account_wiki
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_account_wiki',
+    'Get the compiled wiki for a company/account. Returns all wiki pages with intelligence, battle cards, and playbook content for that account.',
+    {
+      accountId: z.string().describe('Company/account ID'),
+    },
+    async (args) => {
+      try {
+        const result = await api('GET', `/api/v1/knowledge/wiki/${args.accountId}`);
+        const pages = result?.data || result?.pages || [];
+
+        if (!pages || pages.length === 0) {
+          return md(`## Account Wiki\n\nNo wiki pages found for account ${args.accountId}.\n`);
+        }
+
+        let text = `## Account Wiki (${pages.length} pages)\n\n`;
+        for (const page of pages) {
+          text += `### ${page.title || page.pageType || 'Untitled'}\n\n`;
+          if (page.content) {
+            // Truncate long content for readability
+            const content = page.content.length > 500
+              ? page.content.slice(0, 500) + '...'
+              : page.content;
+            text += content + '\n\n';
+          }
+        }
+        return md(text);
+      } catch (err) {
+        return mdError('Account wiki retrieval failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // create_knowledge_file
+  // -----------------------------------------------------------------------
+  server.tool(
+    'create_knowledge_file',
+    'Create a knowledge file (battle card, playbook, competitive brief, objection handler, etc.). Saves to the knowledge hub for team-wide access.',
+    {
+      title: z.string().describe('File title'),
+      fileType: z.string().describe('Type: battlecard, playbook, competitive_brief, objection_handler, process_doc, template'),
+      content: z.string().describe('File content (markdown supported)'),
+      category: z.string().optional().describe('Category for organization'),
+    },
+    async (args) => {
+      try {
+        const body = {
+          title: args.title,
+          fileType: args.fileType,
+          content: args.content,
+        };
+        if (args.category) body.category = args.category;
+
+        const result = await api('POST', '/api/v1/knowledge/files', { body });
+        const file = result?.data || result;
+
+        return md(
+          `## Knowledge File Created\n\n` +
+          `- **Title:** ${file.title || args.title}\n` +
+          `- **ID:** ${file.id || '\u2014'}\n` +
+          `- **Type:** ${file.fileType || args.fileType}\n` +
+          `- **Category:** ${file.category || args.category || '\u2014'}\n`
+        );
+      } catch (err) {
+        return mdError('Knowledge file creation failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // link_file_to_entity
+  // -----------------------------------------------------------------------
+  server.tool(
+    'link_file_to_entity',
+    'Connect a knowledge file to a CRM record (company, person, opportunity). Links battle cards to accounts, playbooks to deals, etc.',
+    {
+      fileId: z.string().describe('Knowledge file ID'),
+      entityType: z.string().describe('Entity type: company, person, opportunity'),
+      entityId: z.string().describe('Entity ID to link to'),
+    },
+    async (args) => {
+      try {
+        const body = {
+          entityType: args.entityType,
+          entityId: args.entityId,
+        };
+
+        await api('POST', `/api/v1/knowledge/files/${args.fileId}/entities`, { body });
+
+        return md(
+          `## File Linked\n\n` +
+          `- **File:** ${args.fileId}\n` +
+          `- **Linked to:** ${args.entityType} ${args.entityId}\n`
+        );
+      } catch (err) {
+        return mdError('File linking failed', err.message);
+      }
+    }
+  );
+}

package/toolsets/matrix.js

@@ -0,0 +1,217 @@
+/**
+ * Matrix Toolset (10 tools, Pro tier)
+ *
+ * Read-only wrappers around the URL-only Matrix analytics surface.
+ */
+
+import { z } from 'zod';
+import { md, mdError } from '../output-formatter.js';
+
+function renderJson(title, data) {
+  return md(`## ${title}\n\n\`\`\`json\n${JSON.stringify(data, null, 2)}\n\`\`\`\n`);
+}
+
+export function register(server, api, AUTH) {
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.pipeline_snapshot_diff', 'matrix_pipeline_snapshot_diff'],
+    description: 'Read Matrix pipeline snapshot movement: open pipeline, created amount, slipped amount, and delta.',
+    path: '/api/v1/analytics/matrix/pipeline/snapshot-diff',
+    title: 'Matrix Pipeline Snapshot Diff',
+    schema: {
+      sinceDays: z.number().int().min(1).max(90).optional().describe('Baseline window in days. Default 1.'),
+    },
+    params: (args) => ({ sinceDays: args.sinceDays }),
+  });
+
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.pipeline_deal_health_queue', 'matrix_pipeline_deal_health_queue'],
+    description: 'Read Matrix deal-health queue ranked by dollars at risk and evidence recency.',
+    path: '/api/v1/analytics/matrix/pipeline/deal-health-queue',
+    title: 'Matrix Deal Health Queue',
+    schema: {
+      limit: z.number().int().min(1).max(50).optional().describe('Max deals to return. Default 20.'),
+    },
+    params: (args) => ({ limit: args.limit }),
+  });
+
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.market_competitor_pulse', 'matrix_market_competitor_pulse'],
+    description: 'Read Matrix competitor pulse rows with win-rate and event context.',
+    path: '/api/v1/analytics/matrix/market/competitor-pulse',
+    title: 'Matrix Competitor Pulse',
+  });
+
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.market_competitor_deal_coaching', 'matrix_market_competitor_deal_coaching'],
+    description: 'Read Matrix competitor-aware deal coaching recommendations for in-flight opportunities.',
+    path: '/api/v1/analytics/matrix/market/competitor-deal-coaching',
+    title: 'Matrix Competitor Deal Coaching',
+    schema: {
+      limit: z.number().int().min(1).max(50).optional().describe('Max coaching rows to return. Default 10.'),
+    },
+    params: (args) => ({ limit: args.limit }),
+  });
+
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.people_causal_lift', 'matrix_people_causal_lift'],
+    description: 'Read Matrix people causal-lift estimates with confidence intervals and assumptions.',
+    path: '/api/v1/analytics/matrix/people/causal-lift',
+    title: 'Matrix People Causal Lift',
+  });
+
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.people_single_thread_risk', 'matrix_people_single_thread_risk'],
+    description: 'Read Matrix single-thread and champion-risk opportunities by rep.',
+    path: '/api/v1/analytics/matrix/people/single-thread-risk',
+    title: 'Matrix People Single-Thread Risk',
+    schema: {
+      limit: z.number().int().min(1).max(50).optional().describe('Max opportunities to return. Default 20.'),
+    },
+    params: (args) => ({ limit: args.limit }),
+  });
+
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.forecast_commit_best_worst', 'matrix_forecast_commit_best_worst'],
+    description: 'Read Matrix forecast commit, best-case, worst-case, and confidence bands.',
+    path: '/api/v1/analytics/matrix/forecast/commit-best-worst',
+    title: 'Matrix Forecast Commit Best Worst',
+  });
+
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.forecast_multi_model_consensus', 'matrix_forecast_multi_model_consensus'],
+    description: 'Read Matrix DHC/survival/conformal disagreement rows for forecast inspection.',
+    path: '/api/v1/analytics/matrix/forecast/multi-model-consensus',
+    title: 'Matrix Forecast Multi-Model Consensus',
+    schema: {
+      limit: z.number().int().min(1).max(50).optional().describe('Max rows to return. Default 12.'),
+    },
+    params: (args) => ({ limit: args.limit }),
+  });
+
+  registerGetTool(server, api, {
+    names: ['analytics.matrix.anomalies_feed', 'matrix_anomalies_feed'],
+    description: 'Read active Matrix anomalies ranked by dollars at risk with evidence IDs and suggested workflow handoffs.',
+    path: '/api/v1/analytics/matrix/anomalies/feed',
+    title: 'Matrix Anomalies Feed',
+    schema: {
+      limit: z.number().int().min(1).max(25).optional().describe('Max anomalies to return. Default 10.'),
+    },
+    params: (args) => ({ limit: args.limit }),
+  });
+
+  registerPostTool(server, api, {
+    names: ['analytics.matrix.nl_ask', 'matrix_nl_ask'],
+    description: 'Ask Matrix a verified analytics question. Best for pipeline health, deal movement, forecast commit, competitor pulse, and seller risk. Returns cited rows when available.',
+    path: '/api/v1/analytics/matrix/nl/ask',
+    title: 'Matrix Answer',
+    schema: {
+      question: z.string().describe('Question to ask Matrix. Example: Which deals slipped this week?'),
+    },
+    body: (args) => ({ question: args.question }),
+  });
+
+  // Backwards-compatible aliases from the first Matrix MCP batch.
+  server.tool(
+    'ask_matrix',
+    'Alias for matrix_nl_ask.',
+    { question: z.string().describe('Question to ask Matrix.') },
+    async (args) => callPost(api, '/api/v1/analytics/matrix/nl/ask', { question: args.question }, 'Matrix Answer')
+  );
+
+  server.tool(
+    'get_matrix_anomalies',
+    'Alias for matrix_anomalies_feed.',
+    {
+      limit: z.number().optional().describe('Max anomalies to return. Default 10, max 25.'),
+    },
+    async (args) => {
+      try {
+        const result = await api('GET', '/api/v1/analytics/matrix/anomalies/feed', { params: { limit: args.limit } });
+        return renderJson('Matrix Anomalies Feed', result?.data || result);
+      } catch (err) {
+        return mdError('Matrix anomalies failed', err.message);
+      }
+    }
+  );
+
+  server.tool(
+    'get_matrix_deal_probability',
+    'Get a Matrix posterior win probability and evidence chain for one opportunity.',
+    {
+      opportunityId: z.string().describe('Opportunity ID'),
+    },
+    async (args) => {
+      try {
+        const result = await api('GET', `/api/v1/analytics/matrix/forecast/deal-probability/${args.opportunityId}`);
+        return renderJson('Matrix Deal Probability', result?.data || result);
+      } catch (err) {
+        return mdError('Matrix deal probability failed', err.message);
+      }
+    }
+  );
+
+  server.tool(
+    'get_matrix_recommended_actions',
+    'Get EV-ranked Matrix actions for an opportunity, including workflow template keys.',
+    {
+      opportunityId: z.string().describe('Opportunity ID'),
+    },
+    async (args) => {
+      try {
+        const result = await api('GET', `/api/v1/analytics/matrix/forecast/recommended-actions/${args.opportunityId}`);
+        return renderJson('Matrix Recommended Actions', result?.data || result);
+      } catch (err) {
+        return mdError('Matrix recommended actions failed', err.message);
+      }
+    }
+  );
+
+  server.tool(
+    'get_matrix_digest_preview',
+    'Preview the Matrix morning digest: top anomalies, slipping deals, competitor event, and deep links.',
+    {},
+    async () => {
+      try {
+        const result = await api('GET', '/api/v1/analytics/matrix/digest/preview');
+        return renderJson('Matrix Digest Preview', result?.data || result);
+      } catch (err) {
+        return mdError('Matrix digest preview failed', err.message);
+      }
+    }
+  );
+}
+
+function registerGetTool(server, api, { name, names, description, path, title, schema = {}, params = () => ({}) }) {
+  for (const toolName of names || [name]) {
+    server.tool(toolName, description, schema, async (args) => {
+      try {
+        const result = await api('GET', path, { params: params(args) });
+        return renderJson(title, result?.data || result);
+      } catch (err) {
+        return mdError(`${title} failed`, err.message);
+      }
+    });
+  }
+}
+
+function registerPostTool(server, api, { name, names, description, path, title, schema = {}, body = () => ({}) }) {
+  for (const toolName of names || [name]) {
+    server.tool(toolName, description, schema, async (args) => {
+      try {
+        const result = await api('POST', path, { body: body(args) });
+        return renderJson(title, result?.data || result);
+      } catch (err) {
+        return mdError(`${title} failed`, err.message);
+      }
+    });
+  }
+}
+
+async function callPost(api, path, body, title) {
+  try {
+    const result = await api('POST', path, { body });
+    return renderJson(title, result?.data || result);
+  } catch (err) {
+    return mdError(`${title} failed`, err.message);
+  }
+}