@adrata/adrata-mcp 1.0.0

package/tools/morning-brief.js

@@ -0,0 +1,551 @@
+/**
+ * Morning Brief — the hero experience that creates daily habit.
+ *
+ * On the first tool call of each day, Adrata delivers a proactive morning
+ * brief: top priorities, overnight signals, pipeline health, calendar prep,
+ * and a single decisive coaching directive.
+ *
+ * Tier behavior:
+ *   - Free tier:  teaser brief (1 signal + upgrade prompt)
+ *   - Pro+ tier:  full brief (parallel API calls, role-adaptive)
+ *
+ * Caching:
+ *   - Cached for the calendar day so it is not repeated in subsequent sessions
+ *   - Cache stored locally in ~/.adrata/morning-brief-cache.json
+ *   - last_morning_brief_date tracked in memory
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Cache layer — one brief per calendar day
+// ---------------------------------------------------------------------------
+
+const ADRATA_DIR = join(homedir(), '.adrata');
+const CACHE_FILE = join(ADRATA_DIR, 'morning-brief-cache.json');
+
+function ensureDir() {
+  if (!existsSync(ADRATA_DIR)) {
+    mkdirSync(ADRATA_DIR, { recursive: true });
+  }
+}
+
+function todayKey() {
+  return new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+}
+
+function readCache() {
+  ensureDir();
+  if (!existsSync(CACHE_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeCache(cache) {
+  ensureDir();
+  writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+}
+
+function getCachedBrief() {
+  const cache = readCache();
+  const today = todayKey();
+  if (cache.date === today && cache.brief) {
+    return cache.brief;
+  }
+  return null;
+}
+
+function setCachedBrief(brief) {
+  writeCache({ date: todayKey(), brief });
+}
+
+// ---------------------------------------------------------------------------
+// Role detection
+// ---------------------------------------------------------------------------
+
+/**
+ * Determine user role from profile data. Falls back to 'ae' (Account Exec)
+ * which gives a balanced brief.
+ */
+function detectRole(profileData) {
+  if (!profileData) return 'ae';
+  const role = (profileData.user?.role || '').toLowerCase();
+  if (role.includes('sdr') || role.includes('bdr') || role.includes('development')) return 'sdr';
+  if (role.includes('vp') || role.includes('director') || role.includes('head') || role.includes('manager')) return 'vp';
+  if (role.includes('ae') || role.includes('account exec') || role.includes('executive')) return 'ae';
+  return 'ae';
+}
+
+// ---------------------------------------------------------------------------
+// Greeting based on time of day
+// ---------------------------------------------------------------------------
+
+function greeting() {
+  const hour = new Date().getHours();
+  if (hour < 12) return 'Good morning';
+  if (hour < 17) return 'Good afternoon';
+  return 'Good evening';
+}
+
+// ---------------------------------------------------------------------------
+// Parallel data fetching (Pro tier)
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch all brief data in parallel. Each call is wrapped so a single failure
+ * does not break the entire brief.
+ *
+ * These hit the REAL platform endpoints. The previous `/api/v1/mcp/speedrun`,
+ * `/api/v1/mcp/intent-signals`, `/api/v1/mcp/emails`,
+ * `/api/v1/mcp/pipeline-metrics`, and `/api/v1/mcp/calendar` paths never
+ * existed (all 404'd), so every Pro brief silently rendered the "quiet night"
+ * fallback.
+ */
+async function fetchBriefData(apiFn) {
+  const safe = async (fn) => {
+    try {
+      return await fn();
+    } catch {
+      return null;
+    }
+  };
+
+  const [serverBrief, speedrun, signals, emails, pipeline, calendar, profile] = await Promise.all([
+    // Canonical server-generated morning brief (null until generated).
+    safe(() => apiFn('GET', '/api/v1/morning-brief')),
+    // Ranked speedrun/today's list.
+    safe(() => apiFn('GET', '/api/v1/speedrun', { params: { limit: 3 } })),
+    // Intent signals.
+    safe(() => apiFn('GET', '/api/v1/signals/intent', { params: { limit: 5 } })),
+    // Unread inbox messages.
+    safe(() => apiFn('GET', '/api/v1/inbox', { params: { unread: true, limit: 5 } })),
+    // Pipeline metrics.
+    safe(() => apiFn('GET', '/api/v1/metrics/pipeline')),
+    // Upcoming calendar events. The server orders by startTime ASC over ALL
+    // history, so without a start_date floor this returned the five OLDEST
+    // events ever recorded. Pass the full current instant (a bare date would
+    // be read as UTC midnight — up to 17h off for a Pacific user), and no
+    // end_date: the server applies it to the nullable endTime column, which
+    // silently drops all-day/imported events. ASC + limit already bounds the
+    // window to the next five events.
+    safe(() =>
+      apiFn('GET', '/api/v1/events', {
+        params: { start_date: new Date().toISOString(), limit: 5 },
+      })
+    ),
+    safe(() => apiFn('GET', '/api/v1/mcp/profile')),
+  ]);
+
+  return { serverBrief, speedrun, signals, emails, pipeline, calendar, profile };
+}
+
+// ---------------------------------------------------------------------------
+// Markdown formatters
+// ---------------------------------------------------------------------------
+
+function formatSignals(signals, role) {
+  if (!signals?.data?.length) return null;
+
+  const items = signals.data.slice(0, role === 'vp' ? 5 : 3);
+  const lines = items.map((s, i) => {
+    const company = s.company_name || s.company || 'Unknown';
+    const signal = s.signal_type || s.type || 'activity';
+    const detail = s.description || s.summary || '';
+    const score = s.intent_score != null ? ` Intent: ${s.intent_score}.` : '';
+    const action = s.recommended_action || s.action || '';
+    return `${i + 1}. **${company}** ${detail}${score}\n   -> ${action || `Follow up on ${signal} signal.`}`;
+  });
+
+  return `### Overnight Signals\n\n${lines.join('\n\n')}`;
+}
+
+function formatSpeedrun(speedrun, role) {
+  if (!speedrun?.data?.length) return null;
+
+  if (role === 'vp') {
+    // VP sees a summary, not individual accounts
+    return null;
+  }
+
+  const items = speedrun.data.slice(0, 3);
+  const rows = items.map((s, i) => {
+    const name = s.company_name || s.name || 'Account';
+    const reason = s.reason || s.why_today || s.summary || 'Priority account';
+    return `| ${i + 1} | ${name} | ${reason} |`;
+  });
+
+  // "Speedrun" is retired product naming; the surface is "today's list". The
+  // /api/v1/speedrun route keeps its name for compatibility.
+  return `### Today's List (Top 3)\n\n| # | Account | Why Today |\n|---|---------|-----------|\n${rows.join('\n')}`;
+}
+
+function formatPipeline(pipeline) {
+  if (!pipeline?.data) return null;
+
+  const d = pipeline.data;
+  const parts = [];
+  if (d.weighted_value != null) parts.push(`$${formatCurrency(d.weighted_value)} weighted`);
+  if (d.closing_this_month != null) parts.push(`${d.closing_this_month} closing this month`);
+  if (d.at_risk != null) parts.push(`${d.at_risk} at risk`);
+  if (d.deals_advanced != null) parts.push(`${d.deals_advanced} advanced`);
+  if (d.deals_stalled != null) parts.push(`${d.deals_stalled} stalled`);
+
+  if (parts.length === 0) return null;
+
+  return `### Pipeline Health\n${parts.join(' | ')}`;
+}
+
+function formatCalendar(calendar) {
+  if (!calendar?.data?.length) return null;
+
+  const meetings = calendar.data.slice(0, 5);
+  const rows = meetings.map((m) => {
+    // Render in the seller's local time; the API returns UTC ISO strings.
+    const rawTime = m.startTime || m.start_time || m.time || '';
+    const parsed = rawTime ? new Date(rawTime) : null;
+    const time =
+      parsed && !Number.isNaN(parsed.getTime())
+        ? parsed.toLocaleString(undefined, {
+            weekday: 'short',
+            month: 'short',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: '2-digit',
+          })
+        : rawTime;
+    const title = m.title || m.subject || 'Meeting';
+    const attendees = m.attendee_count || m.attendees?.length || '?';
+    const prep = m.prep_note || '';
+    return `- **${time}** ${title} (${attendees} attendees)${prep ? `\n  -> ${prep}` : ''}`;
+  });
+
+  return `### Calendar\n\n${rows.join('\n')}`;
+}
+
+function formatEmails(emails) {
+  if (!emails?.data?.length) return null;
+
+  const count = emails.data.length;
+  const hasMore = emails.meta?.total_count > count;
+  const preview = emails.data.slice(0, 3).map((e) => {
+    const from = e.from_name || e.from || 'Someone';
+    const subject = e.subject || 'No subject';
+    return `- **${from}**: ${subject}`;
+  });
+
+  const moreText = hasMore ? `\n\n${emails.meta.total_count - count} more unread.` : '';
+  return `### New Replies\n\n${preview.join('\n')}${moreText}`;
+}
+
+function formatCurrency(value) {
+  if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
+  if (value >= 1_000) return `${(value / 1_000).toFixed(0)}K`;
+  return String(value);
+}
+
+// ---------------------------------------------------------------------------
+// Role-adaptive section ordering
+// ---------------------------------------------------------------------------
+
+function buildProBrief(data, role) {
+  const { serverBrief, speedrun, signals, emails, pipeline, calendar } = data;
+  const sections = [];
+
+  // Header is appended last (see below) so it can describe what the brief
+  // actually contains. It used to be a hardcoded "Three things before your
+  // 10am.", which invented a meeting for any user whose calendar was empty and
+  // contradicted itself after midday ("Good afternoon ... before your 10am").
+  const headerIndex = sections.length;
+  sections.push('');
+
+  // Canonical server-generated brief, when one exists for today.
+  const briefBody = serverBrief?.data?.content || serverBrief?.data?.summary;
+  if (typeof briefBody === 'string' && briefBody.trim()) {
+    sections.push(briefBody.trim());
+  }
+
+  // SDR: prospecting focus — signals first, speedrun, emails
+  // AE:  deal focus — signals, pipeline, calendar, speedrun
+  // VP:  pipeline focus — pipeline, signals, calendar
+  if (role === 'sdr') {
+    const s = formatSignals(signals, role);
+    const sr = formatSpeedrun(speedrun, role);
+    const e = formatEmails(emails);
+    if (s) sections.push(s);
+    if (sr) sections.push(sr);
+    if (e) sections.push(e);
+    const p = formatPipeline(pipeline);
+    if (p) sections.push(p);
+  } else if (role === 'vp') {
+    const p = formatPipeline(pipeline);
+    const s = formatSignals(signals, role);
+    const c = formatCalendar(calendar);
+    if (p) sections.push(p);
+    if (s) sections.push(s);
+    if (c) sections.push(c);
+  } else {
+    // AE default
+    const s = formatSignals(signals, role);
+    const c = formatCalendar(calendar);
+    const sr = formatSpeedrun(speedrun, role);
+    const p = formatPipeline(pipeline);
+    const e = formatEmails(emails);
+    if (s) sections.push(s);
+    if (c) sections.push(c);
+    if (sr) sections.push(sr);
+    if (p) sections.push(p);
+    if (e) sections.push(e);
+  }
+
+  // If no data came back at all, give a graceful fallback. Say plainly that
+  // there is nothing rather than pointing at a "#1 account" that may not exist.
+  if (sections.length <= headerIndex + 1) {
+    sections[headerIndex] = `## ${greeting()}.\n`;
+    sections.push('Nothing new overnight — no signals, meetings, or pipeline changes to report.');
+    sections.push('\nRun `/today` for your ranked list. Run `/pipeline` for deal details.');
+    return sections.join('\n\n');
+  }
+
+  sections[headerIndex] = `## ${greeting()}.${nextMeetingClause(calendar)}\n`;
+  sections.push('\nRun `/today` for your ranked list. Run `/pipeline` for deal details. Run `/meeting-prep` for your next meeting.');
+
+  return sections.join('\n\n');
+}
+
+/**
+ * Describe the next upcoming meeting, or say nothing.
+ *
+ * Returns '' when the calendar is empty or every event is in the past, so the
+ * brief never claims a meeting the seller does not have.
+ */
+function nextMeetingClause(calendar) {
+  const events = calendar?.data;
+  if (!Array.isArray(events) || events.length === 0) return '';
+
+  const now = Date.now();
+  const upcoming = events
+    .map((m) => {
+      const raw = m.startTime || m.start_time || m.time || '';
+      const at = raw ? new Date(raw) : null;
+      return at && !Number.isNaN(at.getTime()) ? at : null;
+    })
+    .filter((at) => at && at.getTime() >= now)
+    .sort((a, b) => a - b);
+
+  if (upcoming.length === 0) return '';
+
+  const time = upcoming[0].toLocaleString(undefined, { hour: 'numeric', minute: '2-digit' });
+  return upcoming.length === 1
+    ? ` One meeting today — ${time}.`
+    : ` ${upcoming.length} meetings today, next at ${time}.`;
+}
+
+// ---------------------------------------------------------------------------
+// Free tier teaser
+// ---------------------------------------------------------------------------
+
+function buildFreeBrief() {
+  const greet = greeting();
+  // HONESTY: never fabricate CRM facts. Without a connected workspace we have
+  // no signals, accounts, or pipeline to report — say so plainly.
+  return `## ${greet}.
+
+### No workspace connected
+
+You're not connected to an Adrata workspace, so there is no real data to brief you on — no signals, accounts, or pipeline are available at this tier.
+
+### What the morning brief includes once connected
+
+- **Overnight signals** with intent scores and recommended actions
+- **Pipeline health** — weighted value, deals closing, at-risk alerts
+- **Calendar prep** — intelligence on every meeting before you walk in
+- **Today's list** — your ranked priority accounts and why
+- **One Thing** — the single most important action for the day
+
+Connect a workspace to see real data: run \`connect_workspace\`, or set \`ADRATA_API_KEY\` / \`ADRATA_OAUTH_TOKEN\`.`;
+}
+
+// ---------------------------------------------------------------------------
+// Track last brief date in memory
+// ---------------------------------------------------------------------------
+
+async function trackBriefInMemory(apiFn, auth) {
+  try {
+    if (auth.authenticated) {
+      await apiFn('POST', '/api/v1/mcp/memories', {
+        body: {
+          content: `last_morning_brief_date: ${todayKey()}`,
+          tags: ['system', 'morning_brief'],
+          memory_type: 'fact',
+        },
+      }).catch(() => {});
+    } else {
+      // Local memory tracking via the memories file
+      const MEMORIES_FILE = join(ADRATA_DIR, 'memories.json');
+      let memories = [];
+      if (existsSync(MEMORIES_FILE)) {
+        try {
+          memories = JSON.parse(readFileSync(MEMORIES_FILE, 'utf-8'));
+        } catch {
+          memories = [];
+        }
+      }
+
+      // Remove old morning_brief tracking entries
+      memories = memories.filter(
+        (m) => !(m.tags && m.tags.includes('morning_brief') && m.tags.includes('system'))
+      );
+
+      memories.push({
+        id: `brief-${todayKey()}`,
+        content: `last_morning_brief_date: ${todayKey()}`,
+        memory_type: 'fact',
+        tags: ['system', 'morning_brief'],
+        confidence: 1.0,
+        is_latest: true,
+        forgotten_at: null,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      });
+
+      writeFileSync(MEMORIES_FILE, JSON.stringify(memories, null, 2));
+    }
+  } catch {
+    // Non-critical — do not fail the brief
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main brief generation
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate the morning brief. Returns { brief, cached } where `cached` is
+ * true if this is a repeat call on the same day.
+ */
+async function generateMorningBrief(apiFn, auth) {
+  // Check cache first
+  const cached = getCachedBrief();
+  if (cached) {
+    return { brief: cached, cached: true };
+  }
+
+  let brief;
+
+  if (auth.authenticated) {
+    // Pro/Enterprise: full brief with parallel data fetch
+    const data = await fetchBriefData(apiFn);
+    const role = detectRole(data.profile?.data || data.profile);
+    brief = buildProBrief(data, role);
+  } else {
+    // Free tier: teaser
+    brief = buildFreeBrief();
+  }
+
+  // Cache for the day
+  setCachedBrief(brief);
+
+  // Track in memory (fire and forget)
+  trackBriefInMemory(apiFn, auth).catch(() => {});
+
+  return { brief, cached: false };
+}
+
+// ---------------------------------------------------------------------------
+// MCP tool registration
+// ---------------------------------------------------------------------------
+
+/**
+ * Register the morning_brief tool on the MCP server.
+ *
+ * @param {object}   server - McpServer instance
+ * @param {object}   z      - Zod instance from MCP SDK
+ * @param {Function} apiFn  - The api() helper
+ * @param {object}   auth   - AUTH context
+ * @param {Function} okFn   - The ok() response helper
+ */
+export function registerMorningBrief(server, z, apiFn, auth, okFn) {
+  server.tool(
+    'morning_brief',
+    'Get your daily morning intelligence brief. Delivers top priorities, overnight signals, pipeline health, calendar prep, and coaching — all in 30 seconds. Automatically adapts to your role (SDR/AE/VP). Cached per day so it runs fast on repeat calls. This is the first thing to check every morning.',
+    {
+      force_refresh: z
+        .boolean()
+        .optional()
+        .describe('Force regeneration even if already delivered today (default: false)'),
+      role_override: z
+        .enum(['sdr', 'ae', 'vp'])
+        .optional()
+        .describe('Override auto-detected role for brief focus (default: auto-detect from profile)'),
+    },
+    async (args) => {
+      const startTime = Date.now();
+
+      // Handle force refresh
+      if (args.force_refresh) {
+        writeCache({});
+      }
+
+      try {
+        // Check cache (unless force refresh)
+        if (!args.force_refresh) {
+          const cached = getCachedBrief();
+          if (cached) {
+            return okFn({
+              morning_brief: cached,
+              cached: true,
+              generated_at: todayKey(),
+              note: 'Cached from earlier today. Use force_refresh=true to regenerate.',
+            });
+          }
+        }
+
+        let brief;
+
+        if (auth.authenticated) {
+          // Pro/Enterprise: full parallel data fetch
+          const data = await fetchBriefData(apiFn);
+          const role = args.role_override || detectRole(data.profile?.data || data.profile);
+          brief = buildProBrief(data, role);
+        } else {
+          // Free tier: teaser
+          brief = buildFreeBrief();
+        }
+
+        // Cache for the day
+        setCachedBrief(brief);
+
+        // Track in memory (fire and forget)
+        trackBriefInMemory(apiFn, auth).catch(() => {});
+
+        const latencyMs = Date.now() - startTime;
+
+        return okFn({
+          morning_brief: brief,
+          cached: false,
+          generated_at: todayKey(),
+          latency_ms: latencyMs,
+          tier: auth.tier,
+        });
+      } catch (err) {
+        // Graceful degradation: return a minimal brief rather than an error
+        const fallback = `## ${greeting()}.\n\nBrief generation encountered an issue. Here's what you can do:\n\n- Run \`/today\` for your ranked priority list\n- Run \`/pipeline\` for deal health\n- Run \`/morning\` to retry the brief\n\nError: ${err.message || 'Unknown error'}`;
+
+        return okFn({
+          morning_brief: fallback,
+          cached: false,
+          error: true,
+          generated_at: todayKey(),
+        });
+      }
+    }
+  );
+}
+
+// Export for testing
+export { generateMorningBrief, buildProBrief, buildFreeBrief, detectRole, getCachedBrief, setCachedBrief };