@adrata/adrata-mcp 1.0.0

package/toolsets/crm.js

@@ -0,0 +1,495 @@
+/**
+ * CRM & Data Toolset (6 tools, Enterprise tier)
+ *
+ * manage_company, manage_person, manage_opportunity,
+ * manage_activity, manage_buyer_group, get_action_history
+ */
+
+import { z } from 'zod';
+import {
+  md, mdError, table, formatEntityTimeline, formatDate,
+} from '../output-formatter.js';
+
+export function register(server, api, AUTH) {
+
+  // -----------------------------------------------------------------------
+  // manage_company
+  // -----------------------------------------------------------------------
+  server.tool(
+    'manage_company',
+    'Full CRUD for companies: create, read, update, delete, enrich, and view activity timeline. One tool for all company operations.',
+    {
+      action: z.enum(['create', 'get', 'update', 'delete', 'enrich', 'timeline', 'search']).describe('Operation'),
+      id: z.string().optional().describe('Company ID (for get/update/delete/enrich/timeline)'),
+      name: z.string().optional().describe('Company name'),
+      domain: z.string().optional().describe('Company domain'),
+      industry: z.string().optional().describe('Industry'),
+      website: z.string().optional().describe('Website URL'),
+      status: z.string().optional().describe('ACTIVE, PROSPECT, CUSTOMER, CHURNED'),
+      customFields: z.record(z.unknown()).optional().describe('Custom fields (JSONB merged)'),
+      query: z.string().optional().describe('Search query (for search action)'),
+    },
+    async (args) => {
+      try {
+        switch (args.action) {
+          case 'create': {
+            const body = {};
+            if (args.name) body.name = args.name;
+            if (args.domain) body.domain = args.domain;
+            if (args.industry) body.industry = args.industry;
+            if (args.website) body.website = args.website;
+            if (args.status) body.status = args.status;
+            if (args.customFields) body.customFields = args.customFields;
+            const result = await api('POST', '/api/v1/companies', { body });
+            const c = result?.data || result;
+            return md(`## Company Created\n\n- **Name:** ${c.name || args.name}\n- **ID:** ${c.id || '\u2014'}\n- **Status:** ${c.status || 'PROSPECT'}\n`);
+          }
+          case 'get': {
+            const c = await api('GET', `/api/v1/companies/${args.id}`);
+            const data = c?.data || c;
+            let text = `## ${data.name || 'Company'}\n\n`;
+            text += `- **ID:** ${data.id}\n- **Industry:** ${data.industry || '\u2014'}\n`;
+            text += `- **Size:** ${data.employeeCount || data.size || '\u2014'}\n`;
+            text += `- **Status:** ${data.status || '\u2014'}\n- **Website:** ${data.website || data.domain || '\u2014'}\n`;
+            if (data.customFields && Object.keys(data.customFields).length > 0) {
+              text += '\n### Custom Fields\n';
+              Object.entries(data.customFields).forEach(([k, v]) => { text += `- **${k}:** ${v}\n`; });
+            }
+            return md(text);
+          }
+          case 'update': {
+            const body = {};
+            if (args.name) body.name = args.name;
+            if (args.industry) body.industry = args.industry;
+            if (args.website) body.website = args.website;
+            if (args.status) body.status = args.status;
+            if (args.customFields) body.customFields = args.customFields;
+            await api('PATCH', `/api/v1/companies/${args.id}`, { body });
+            return md(`## Company Updated\n\nID: ${args.id}\nFields updated: ${Object.keys(body).join(', ')}\n`);
+          }
+          case 'delete': {
+            await api('DELETE', `/api/v1/companies/${args.id}`);
+            return md(`## Company Deleted\n\nID: ${args.id}\n`);
+          }
+          case 'enrich': {
+            await api('POST', `/api/v1/companies/${args.id}/enrich`);
+            return md(`## Enrichment Triggered\n\nCompany ID: ${args.id}\nData will be available shortly.\n`);
+          }
+          case 'timeline': {
+            const [company, actions] = await Promise.all([
+              api('GET', `/api/v1/companies/${args.id}`).then(r => r?.data || r),
+              api('GET', `/api/v1/companies/${args.id}/actions`, { params: { limit: 25, page: 1 } }),
+            ]);
+            return md(formatEntityTimeline(company, actions));
+          }
+          case 'search': {
+            const result = await api('GET', '/api/v1/companies', { params: { search: args.query || args.name, limit: 25, page: 1 } });
+            const items = result?.data || [];
+            if (items.length === 0) return md('## Company Search\n\nNo companies found.\n');
+            let text = `## ${items.length} Companies Found\n\n`;
+            const rows = items.map(c => [c.name || '\u2014', c.industry || '\u2014', c.status || '\u2014', c.domain || '\u2014']);
+            text += table(['Name', 'Industry', 'Status', 'Domain'], rows);
+            return md(text);
+          }
+          default:
+            return mdError(`Unknown action: ${args.action}`);
+        }
+      } catch (err) {
+        return mdError('Company operation failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // manage_person
+  // -----------------------------------------------------------------------
+  server.tool(
+    'manage_person',
+    'Full CRUD for people/contacts: create, read, update, delete, enrich, and view communication history.',
+    {
+      action: z.enum(['create', 'get', 'update', 'delete', 'enrich', 'timeline', 'search']).describe('Operation'),
+      id: z.string().optional().describe('Person ID'),
+      name: z.string().optional(),
+      firstName: z.string().optional(),
+      lastName: z.string().optional(),
+      email: z.string().optional(),
+      phone: z.string().optional(),
+      title: z.string().optional(),
+      companyId: z.string().optional(),
+      status: z.string().optional().describe('LEAD, PROSPECT, CUSTOMER'),
+      linkedinUrl: z.string().optional(),
+      customFields: z.record(z.unknown()).optional(),
+      query: z.string().optional().describe('Search query'),
+    },
+    async (args) => {
+      try {
+        switch (args.action) {
+          case 'create': {
+            const body = {};
+            ['name', 'firstName', 'lastName', 'email', 'phone', 'title', 'companyId', 'status', 'linkedinUrl', 'customFields'].forEach(k => {
+              if (args[k] !== undefined) body[k] = args[k];
+            });
+            const result = await api('POST', '/api/v1/people', { body });
+            const p = result?.data || result;
+            return md(`## Person Created\n\n- **Name:** ${p.name || args.name || `${args.firstName} ${args.lastName}`}\n- **ID:** ${p.id || '\u2014'}\n- **Email:** ${p.email || args.email || '\u2014'}\n`);
+          }
+          case 'get': {
+            const p = await api('GET', `/api/v1/people/${args.id}`);
+            const data = p?.data || p;
+            let text = `## ${data.name || `${data.firstName} ${data.lastName}`}\n\n`;
+            text += `- **Title:** ${data.title || '\u2014'}\n- **Company:** ${data.companyName || '\u2014'}\n`;
+            text += `- **Email:** ${data.email || '\u2014'}\n- **Phone:** ${data.phone || '\u2014'}\n`;
+            text += `- **Status:** ${data.status || '\u2014'}\n- **LinkedIn:** ${data.linkedinUrl || '\u2014'}\n`;
+            return md(text);
+          }
+          case 'update': {
+            const body = {};
+            ['name', 'firstName', 'lastName', 'email', 'phone', 'title', 'status', 'linkedinUrl', 'customFields'].forEach(k => {
+              if (args[k] !== undefined) body[k] = args[k];
+            });
+            await api('PATCH', `/api/v1/people/${args.id}`, { body });
+            return md(`## Person Updated\n\nID: ${args.id}\nFields: ${Object.keys(body).join(', ')}\n`);
+          }
+          case 'delete': {
+            await api('DELETE', `/api/v1/people/${args.id}`);
+            return md(`## Person Deleted\n\nID: ${args.id}\n`);
+          }
+          case 'enrich': {
+            await api('POST', `/api/v1/people/${args.id}/enrich`);
+            return md(`## Enrichment Triggered\n\nPerson ID: ${args.id}\n`);
+          }
+          case 'timeline': {
+            const [person, actions] = await Promise.all([
+              api('GET', `/api/v1/people/${args.id}`).then(r => r?.data || r),
+              api('GET', '/api/v1/actions', { params: { personId: args.id, limit: 25, page: 1 } }),
+            ]);
+            return md(formatEntityTimeline(person, actions));
+          }
+          case 'search': {
+            const result = await api('GET', '/api/v1/people', { params: { search: args.query || args.name || args.email, limit: 25, page: 1 } });
+            const items = result?.data || [];
+            if (items.length === 0) return md('## Person Search\n\nNo people found.\n');
+            let text = `## ${items.length} People Found\n\n`;
+            const rows = items.map(p => [p.name || '\u2014', p.title || '\u2014', p.companyName || '\u2014', p.email || '\u2014']);
+            text += table(['Name', 'Title', 'Company', 'Email'], rows);
+            return md(text);
+          }
+          default:
+            return mdError(`Unknown action: ${args.action}`);
+        }
+      } catch (err) {
+        return mdError('Person operation failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // manage_opportunity
+  // -----------------------------------------------------------------------
+  server.tool(
+    'manage_opportunity',
+    'Full CRUD for deals/opportunities: create, read, update, delete, view stage history and stakeholders.',
+    {
+      action: z.enum(['create', 'get', 'update', 'delete', 'search']).describe('Operation'),
+      id: z.string().optional().describe('Opportunity ID'),
+      name: z.string().optional(),
+      companyId: z.string().optional(),
+      amount: z.number().optional(),
+      stage: z.string().optional().describe('Discovery, Qualification, Proposal, Negotiation, Closed Won, Closed Lost'),
+      probability: z.number().optional(),
+      closeDate: z.string().optional(),
+      ownerId: z.string().optional(),
+      customFields: z.record(z.unknown()).optional(),
+      query: z.string().optional(),
+    },
+    async (args) => {
+      try {
+        switch (args.action) {
+          case 'create': {
+            const body = {};
+            ['name', 'companyId', 'amount', 'stage', 'probability', 'closeDate', 'ownerId', 'customFields'].forEach(k => {
+              if (args[k] !== undefined) body[k] = args[k];
+            });
+            const result = await api('POST', '/api/v1/opportunities', { body });
+            const o = result?.data || result;
+            return md(`## Opportunity Created\n\n- **Name:** ${o.name || args.name}\n- **ID:** ${o.id || '\u2014'}\n- **Amount:** $${(o.amount || args.amount || 0).toLocaleString()}\n- **Stage:** ${o.stage || args.stage || 'Discovery'}\n`);
+          }
+          case 'get': {
+            const o = await api('GET', `/api/v1/opportunities/${args.id}`);
+            const data = o?.data || o;
+            let text = `## ${data.name || 'Opportunity'}\n\n`;
+            text += `- **Amount:** $${(data.amount || 0).toLocaleString()}\n`;
+            text += `- **Stage:** ${data.stage || '\u2014'}\n`;
+            text += `- **Probability:** ${data.probability || 0}%\n`;
+            text += `- **Close Date:** ${formatDate(data.closeDate || data.expectedCloseDate)}\n`;
+            text += `- **Company:** ${data.companyId || '\u2014'}\n`;
+            return md(text);
+          }
+          case 'update': {
+            const body = {};
+            ['name', 'amount', 'stage', 'probability', 'closeDate', 'customFields'].forEach(k => {
+              if (args[k] !== undefined) body[k] = args[k];
+            });
+            await api('PATCH', `/api/v1/opportunities/${args.id}`, { body });
+            return md(`## Opportunity Updated\n\nID: ${args.id}\nFields: ${Object.keys(body).join(', ')}\n`);
+          }
+          case 'delete': {
+            await api('DELETE', `/api/v1/opportunities/${args.id}`);
+            return md(`## Opportunity Deleted\n\nID: ${args.id}\n`);
+          }
+          case 'search': {
+            const result = await api('GET', '/api/v1/opportunities', { params: { search: args.query || args.name, limit: 25, page: 1 } });
+            const items = result?.data || [];
+            if (items.length === 0) return md('## Opportunity Search\n\nNo opportunities found.\n');
+            let text = `## ${items.length} Opportunities\n\n`;
+            const rows = items.map(o => [
+              o.name || '\u2014',
+              `$${(o.amount || 0).toLocaleString()}`,
+              o.stage || '\u2014',
+              `${o.probability || 0}%`,
+              formatDate(o.closeDate),
+            ]);
+            text += table(['Name', 'Amount', 'Stage', 'Prob', 'Close'], rows);
+            return md(text);
+          }
+          default:
+            return mdError(`Unknown action: ${args.action}`);
+        }
+      } catch (err) {
+        return mdError('Opportunity operation failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // manage_activity
+  // -----------------------------------------------------------------------
+  server.tool(
+    'manage_activity',
+    'Create, update, complete, or list activities (actions, notes, calls, meetings). Auto-logs to CRM timeline.',
+    {
+      action: z.enum(['create', 'get', 'update', 'complete', 'list', 'delete']).describe('Operation'),
+      id: z.string().optional().describe('Action ID'),
+      title: z.string().optional(),
+      type: z.string().optional().describe('email, call, meeting, note, task'),
+      personId: z.string().optional(),
+      companyId: z.string().optional(),
+      status: z.string().optional().describe('PLANNED, IN_PROGRESS, COMPLETED'),
+      priority: z.string().optional().describe('LOW, NORMAL, HIGH, URGENT'),
+      dueDate: z.string().optional(),
+      outcome: z.string().optional(),
+      metadata: z.record(z.unknown()).optional(),
+    },
+    async (args) => {
+      try {
+        switch (args.action) {
+          case 'create': {
+            const body = {};
+            ['title', 'type', 'personId', 'companyId', 'status', 'priority', 'dueDate', 'outcome', 'metadata'].forEach(k => {
+              if (args[k] !== undefined) body[k] = args[k];
+            });
+            const result = await api('POST', '/api/v1/actions', { body });
+            const a = result?.data || result;
+            return md(`## Activity Created\n\n- **Title:** ${a.title || args.title}\n- **Type:** ${a.type || args.type || '\u2014'}\n- **ID:** ${a.id || '\u2014'}\n`);
+          }
+          case 'get': {
+            const a = await api('GET', `/api/v1/actions/${args.id}`);
+            const data = a?.data || a;
+            let text = `## ${data.title || 'Activity'}\n\n`;
+            text += `- **Type:** ${data.type || '\u2014'}\n- **Status:** ${data.status || '\u2014'}\n`;
+            text += `- **Priority:** ${data.priority || '\u2014'}\n- **Due:** ${formatDate(data.dueDate)}\n`;
+            if (data.outcome) text += `- **Outcome:** ${data.outcome}\n`;
+            return md(text);
+          }
+          case 'update': {
+            const body = {};
+            ['title', 'type', 'status', 'priority', 'dueDate', 'outcome', 'metadata'].forEach(k => {
+              if (args[k] !== undefined) body[k] = args[k];
+            });
+            await api('PUT', `/api/v1/actions/${args.id}`, { body });
+            return md(`## Activity Updated\n\nID: ${args.id}\n`);
+          }
+          case 'complete': {
+            if (args.outcome) await api('PUT', `/api/v1/actions/${args.id}`, { body: { outcome: args.outcome } });
+            await api('POST', `/api/v1/actions/${args.id}/complete`);
+            return md(`## Activity Completed\n\nID: ${args.id}${args.outcome ? `\nOutcome: ${args.outcome}` : ''}\n`);
+          }
+          case 'list': {
+            const params = { limit: 25, page: 1 };
+            if (args.personId) params.personId = args.personId;
+            if (args.companyId) params.companyId = args.companyId;
+            if (args.type) params.type = args.type;
+            if (args.status) params.status = args.status;
+            const result = await api('GET', '/api/v1/actions', { params });
+            const items = result?.data || [];
+            if (items.length === 0) return md('## Activities\n\nNo activities found.\n');
+            let text = `## ${items.length} Activities\n\n`;
+            const rows = items.map(a => [
+              a.type || '\u2014',
+              a.title || '\u2014',
+              a.status || '\u2014',
+              formatDate(a.dueDate || a.createdAt),
+            ]);
+            text += table(['Type', 'Title', 'Status', 'Date'], rows);
+            return md(text);
+          }
+          case 'delete': {
+            await api('DELETE', `/api/v1/actions/${args.id}`);
+            return md(`## Activity Deleted\n\nID: ${args.id}\n`);
+          }
+          default:
+            return mdError(`Unknown action: ${args.action}`);
+        }
+      } catch (err) {
+        return mdError('Activity operation failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // manage_buyer_group
+  // -----------------------------------------------------------------------
+  server.tool(
+    'manage_buyer_group',
+    'Full CRUD for buyer groups (decision-making units): create, read, list, update and delete groups, and add/update/remove/list members with roles (Champion, Decision Maker, Influencer, Blocker, End User). Deleting a group cascades to its member seats, so a room never has to be emptied before it can be removed. Use bulk_delete to clear many rooms in one call.',
+    {
+      action: z.enum([
+        'create', 'get', 'list', 'update', 'delete', 'bulk_delete',
+        'add_member', 'update_member', 'remove_member', 'list_members',
+      ]).describe('Operation'),
+      id: z.string().optional().describe('Buyer group ID'),
+      ids: z.array(z.string()).optional().describe('Buyer group IDs (bulk_delete, max 50)'),
+      companyId: z.string().optional().describe('Company ID'),
+      name: z.string().optional().describe('Group name'),
+      personId: z.string().optional().describe('Person ID (add_member/update_member)'),
+      memberId: z.string().optional().describe('Buyer group member ID (update_member/remove_member)'),
+      role: z.string().optional().describe('Champion, Decision Maker, Influencer, Blocker, End User'),
+      influenceScore: z.number().optional().describe('Member influence score (update_member)'),
+    },
+    async (args) => {
+      try {
+        switch (args.action) {
+          case 'create': {
+            const result = await api('POST', '/api/v1/buyer-group', { body: { name: args.name, companyId: args.companyId } });
+            const bg = result?.data || result;
+            return md(`## Buyer Group Created\n\n- **Name:** ${bg.name || args.name}\n- **ID:** ${bg.id || '\u2014'}\n- **Company:** ${args.companyId}\n`);
+          }
+          case 'get': {
+            const bg = await api('GET', `/api/v1/buyer-group/${args.id}`);
+            const data = bg?.data || bg;
+            let text = `## Buyer Group: ${data.name || '\u2014'}\n\n`;
+            text += `- **ID:** ${data.id}\n- **Company:** ${data.companyId || '\u2014'}\n`;
+            return md(text);
+          }
+          case 'list': {
+            const result = await api('GET', '/api/v1/buyer-group', { params: { companyId: args.companyId, limit: 25, page: 1 } });
+            const items = result?.data || [];
+            if (items.length === 0) return md('## Buyer Groups\n\nNo buyer groups found.\n');
+            let text = `## ${items.length} Buyer Groups\n\n`;
+            const rows = items.map(bg => [bg.name || '\u2014', bg.id, bg.companyId || '\u2014']);
+            text += table(['Name', 'ID', 'Company'], rows);
+            return md(text);
+          }
+          case 'update': {
+            const patch = {};
+            if (args.name) patch.name = args.name;
+            if (args.companyId) patch.companyId = args.companyId;
+            if (Object.keys(patch).length === 0) {
+              return mdError('Nothing to update', 'Provide name and/or companyId.');
+            }
+            await api('PUT', `/api/v1/buyer-group/${args.id}`, { body: patch });
+            return md(`## Buyer Group Updated\n\nID: ${args.id}\nFields updated: ${Object.keys(patch).join(', ')}\n`);
+          }
+          case 'delete': {
+            await api('DELETE', `/api/v1/buyer-group/${args.id}`);
+            return md(`## Buyer Group Deleted\n\nID: ${args.id}\n\nThe room's member seats were removed with it. The underlying people and company records are untouched.\n`);
+          }
+          case 'bulk_delete': {
+            const ids = args.ids || [];
+            if (ids.length === 0) return mdError('bulk_delete requires ids', 'Pass an array of buyer group IDs (max 50).');
+            if (ids.length > 50) return mdError('Too many IDs', 'Maximum 50 buyer groups per batch.');
+            const result = await api('DELETE', '/api/v1/buyer-group/bulk', { body: { ids } });
+            const summary = result?.summary || {};
+            return md(`## Buyer Groups Deleted\n\n- **Requested:** ${summary.total ?? ids.length}\n- **Deleted:** ${summary.succeeded ?? '\u2014'}\n- **Failed:** ${summary.failed ?? '\u2014'}\n\nEach deleted room took its member seats with it.\n`);
+          }
+          case 'add_member': {
+            await api('POST', `/api/v1/buyer-group/${args.id}/members`, { body: { personId: args.personId, role: args.role } });
+            return md(`## Member Added\n\n- **Group:** ${args.id}\n- **Person:** ${args.personId}\n- **Role:** ${args.role || '\u2014'}\n`);
+          }
+          case 'update_member': {
+            if (!args.memberId) return mdError('update_member requires memberId', 'Use list_members to find the member ID.');
+            const patch = {};
+            if (args.role) patch.role = args.role;
+            if (args.personId) patch.personId = args.personId;
+            if (args.influenceScore !== undefined) patch.influenceScore = args.influenceScore;
+            await api('PUT', `/api/v1/buyer-group/${args.id}/members/${args.memberId}`, { body: patch });
+            return md(`## Member Updated\n\n- **Group:** ${args.id}\n- **Member:** ${args.memberId}\n- **Fields:** ${Object.keys(patch).join(', ') || '\u2014'}\n`);
+          }
+          case 'remove_member': {
+            if (!args.memberId) return mdError('remove_member requires memberId', 'Use list_members to find the member ID.');
+            await api('DELETE', `/api/v1/buyer-group/${args.id}/members/${args.memberId}`);
+            return md(`## Member Removed\n\n- **Group:** ${args.id}\n- **Member:** ${args.memberId}\n\nThe person record itself was not deleted.\n`);
+          }
+          case 'list_members': {
+            const result = await api('GET', `/api/v1/buyer-group/${args.id}/members`);
+            const members = result?.data || [];
+            if (members.length === 0) return md('## Buyer Group Members\n\nNo members in this group yet.\n');
+            let text = `## Buyer Group Members (${members.length})\n\n`;
+            const rows = members.map(m => [m.name || m.personId || '\u2014', m.role || '\u2014', m.title || '\u2014']);
+            text += table(['Name', 'Role', 'Title'], rows);
+            return md(text);
+          }
+          default:
+            return mdError(`Unknown action: ${args.action}`);
+        }
+      } catch (err) {
+        return mdError('Buyer group operation failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_action_history
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_action_history',
+    'Full activity timeline for any entity: emails, calls, meetings, notes, stage changes. Shows the complete history of interactions with a person, company, or deal.',
+    {
+      entityType: z.enum(['person', 'company', 'opportunity']).describe('Entity type'),
+      entityId: z.string().describe('Entity ID'),
+      limit: z.number().optional().describe('Max items (default 25)'),
+    },
+    async (args) => {
+      try {
+        const limit = args.limit || 25;
+        let entity;
+        let actions;
+
+        switch (args.entityType) {
+          case 'person':
+            [entity, actions] = await Promise.all([
+              api('GET', `/api/v1/people/${args.entityId}`).then(r => r?.data || r),
+              api('GET', '/api/v1/actions', { params: { personId: args.entityId, limit, page: 1 } }),
+            ]);
+            break;
+          case 'company':
+            [entity, actions] = await Promise.all([
+              api('GET', `/api/v1/companies/${args.entityId}`).then(r => r?.data || r),
+              api('GET', `/api/v1/companies/${args.entityId}/actions`, { params: { limit, page: 1 } }),
+            ]);
+            break;
+          case 'opportunity':
+            [entity, actions] = await Promise.all([
+              api('GET', `/api/v1/opportunities/${args.entityId}`).then(r => r?.data || r),
+              api('GET', '/api/v1/actions', { params: { companyId: args.entityId, limit, page: 1 } }),
+            ]);
+            break;
+        }
+
+        return md(formatEntityTimeline(entity, actions));
+      } catch (err) {
+        return mdError('Action history failed', err.message);
+      }
+    }
+  );
+}