slashvibe-mcp 0.3.20 → 0.3.21

package/tools/inbox.js

@@ -5,47 +5,118 @@
 const config = require('../config');
 const store = require('../store');
 const notify = require('../notify');
-const analytics = require('../analytics');
-const { requireInit, header, emptyState, formatTimeAgo, truncate, divider } = require('./_shared');
+const patterns = require('../intelligence/patterns');
+const { formatPayload } = require('../protocol');
+const { requireInit, header, emptyState, formatTimeAgo, truncate, divider, fetchRelevantUsers } = require('./_shared');
 const { actions, formatActions } = require('./_actions');
 
-// Helper: Fetch recent ships for social proof (FOMO)
-async function getRecentShips(limit = 2) {
-  try {
-    const apiUrl = config.getApiUrl();
-    const response = await fetch(`${apiUrl}/api/board?limit=${limit}&category=shipped`);
-    const data = await response.json();
-    return (data.entries || []).map(e => ({
-      author: e.author,
-      content: e.content?.slice(0, 50)
-    }));
-  } catch (e) {
-    return [];
-  }
+// Truncate message for preview (first 100 chars, clean break at word)
+function summarizeMessage(text, maxLen = 100) {
+  if (!text || text.length <= maxLen) return text;
+  const truncated = text.slice(0, maxLen);
+  const lastSpace = truncated.lastIndexOf(' ');
+  return (lastSpace > maxLen * 0.7 ? truncated.slice(0, lastSpace) : truncated) + '...';
 }
 
-// Helper: Get next incomplete onboarding task
-async function getNextOnboardingTask(handle) {
+// Get activity heat icon for a user (borrowed from who.js logic)
+function getStatusIcon(user) {
+  if (!user) return '●';
+
+  // Check mood/status
+  if (user.mood === '🔥' || user.mood === '🚀' || user.builderMode === 'shipping') return '🔥';
+  if (user.mood === '🧠' || user.builderMode === 'deep-focus') return '🧠';
+  if (user.mood === '🐛') return '🐛';
+  if (user.mood === '🌙') return '🌙';
+
+  // Check recency
+  const lastSeenMs = user.lastSeen || Date.now();
+  const minutesAgo = (Date.now() - lastSeenMs) / 60000;
+  if (minutesAgo < 5) return '⚡';
+  if (minutesAgo < 30) return '●';
+  return '○';
+}
+
+// Get status label for a user
+function getStatusLabel(user) {
+  if (!user) return null;
+
+  if (user.mood === '🔥' || user.mood === '🚀' || user.builderMode === 'shipping') return 'shipping';
+  if (user.mood === '🧠' || user.builderMode === 'deep-focus') return 'deep focus';
+  if (user.mood === '🐛') return 'debugging';
+  if (user.mood === '🌙') return 'late night';
+  if (user.mood === '💭') return 'thinking';
+
+  const lastSeenMs = user.lastSeen || Date.now();
+  const minutesAgo = (Date.now() - lastSeenMs) / 60000;
+  if (minutesAgo < 5) return 'active';
+  if (minutesAgo < 30) return 'online';
+  return 'away';
+}
+
+// Build recommended connections display for empty/caught-up inbox
+async function buildRecommendationsDisplay(myHandle) {
+  // Fetch recommendations from relevancy API
+  const relevancy = await fetchRelevantUsers(myHandle, 'dm_suggest', 5);
+
+  if (!relevancy || !relevancy.matches || relevancy.matches.length === 0) {
+    return null; // Fallback to old behavior
+  }
+
+  const matches = relevancy.matches;
+
+  // Get presence info for status display
+  const presenceMap = new Map();
   try {
-    const checklist = await store.getChecklistStatus(handle);
-    if (checklist.success && checklist.tasks) {
-      const nextTask = checklist.tasks.find(t => !t.done);
-      if (nextTask) {
-        // Map task IDs to user-friendly actions
-        const taskActions = {
-          'read_welcome': { shortLabel: 'Read welcome', command: 'check my messages', description: 'See your welcome message' },
-          'reply_seth': { shortLabel: 'Reply to @vibe', command: 'message @vibe', description: 'Say hi back!' },
-          'message_builder': { shortLabel: 'Message a builder', command: 'discover suggest', description: 'Find someone to connect with' },
-          'post_ship': { shortLabel: 'Ship something', command: 'ship what I built', description: 'Share what you\'re building' },
-          'leave_feedback': { shortLabel: 'Give feedback', command: 'talk to @echo', description: 'Help improve /vibe' }
-        };
-        return taskActions[nextTask.id] || null;
-      }
-    }
-    return null;
+    const presence = await store.getPresence();
+    const allUsers = [...(presence.active || []), ...(presence.away || [])];
+    allUsers.forEach(u => {
+      presenceMap.set(u.handle?.toLowerCase(), u);
+    });
   } catch (e) {
-    return null;
+    // Continue without presence info
   }
+
+  // Build preview line (stays visible when collapsed)
+  const top3Handles = matches.slice(0, 3).map(m => `@${m.handle}`).join(', ');
+  let display = `📭 All caught up! Connect with: ${top3Handles}\n\n`;
+
+  // Build ranked list with statuses
+  display += `---\n`;
+
+  matches.forEach(match => {
+    const presenceUser = presenceMap.get(match.handle?.toLowerCase());
+    const icon = getStatusIcon(presenceUser);
+    const statusLabel = getStatusLabel(presenceUser);
+    const statusText = statusLabel ? ` — ${statusLabel}` : '';
+
+    display += `${icon} **@${match.handle}**${statusText}\n`;
+
+    // Show building + first reason
+    if (match.building) {
+      const reason = match.reasons?.[0] ? ` • ${match.reasons[0]}` : '';
+      display += `   "${summarizeMessage(match.building, 50)}"${reason}\n`;
+    } else if (match.reasons?.[0]) {
+      display += `   ${match.reasons[0]}\n`;
+    }
+
+    display += '\n';
+  });
+
+  // Enrich matches with status info for action descriptions
+  const enrichedMatches = matches.map(match => {
+    const presenceUser = presenceMap.get(match.handle?.toLowerCase());
+    return {
+      ...match,
+      statusIcon: getStatusIcon(presenceUser),
+      statusLabel: getStatusLabel(presenceUser)
+    };
+  });
+
+  return {
+    display,
+    matches: enrichedMatches,
+    actions: formatActions(actions.recommendedConnections(enrichedMatches))
+  };
 }
 
 const definition = {
@@ -68,49 +139,72 @@ async function handler(args) {
   notify.checkAll(store);
 
   if (!threads || threads.length === 0) {
-    // Fetch context for retention-optimized actions (parallel for speed)
-    const [recentShips, onboardingTask] = await Promise.all([
-      getRecentShips(2),
-      getNextOnboardingTask(myHandle)
-    ]);
-
-    // Build social proof line
-    let socialProof = '';
-    if (recentShips.length > 0) {
-      socialProof = `\n   💫 @${recentShips[0].author} just shipped`;
+    // Try to show personalized recommendations
+    try {
+      const recommendations = await buildRecommendationsDisplay(myHandle);
+      if (recommendations) {
+        // Change preview line for empty inbox (no messages yet)
+        const display = recommendations.display.replace(
+          'All caught up!',
+          'No messages yet.'
+        );
+        return {
+          display,
+          actions: recommendations.actions
+        };
+      }
+    } catch (e) {
+      console.log('[inbox] recommendations error:', e.message);
     }
 
-    // Build CTA based on onboarding state
-    let cta = onboardingTask
-      ? `→ ${onboardingTask.shortLabel}: "${onboardingTask.command}"`
-      : 'Say "dm @someone" to start';
-
-    // Track empty inbox state for retention analytics
-    analytics.trackEmptyInbox('none', {
-      recentThreads: [],
-      recentShips,
-      onboardingTask,
-      state: 'no_messages'
-    });
+    // Fallback: Check onboarding status to customize CTA
+    let cta = 'Say "dm @someone" to start';
+    try {
+      const checklist = await store.getChecklistStatus(myHandle);
+      if (checklist.success && checklist.tasks) {
+        const repliedToSeth = checklist.tasks.find(t => t.id === 'reply_seth')?.done;
+        if (!repliedToSeth) {
+          cta = 'Reply to @vibe to get started!';
+        }
+      }
+    } catch (e) {}
 
     return {
-      display: `── 📭 Inbox ──────────────────────────
-   No messages yet${socialProof}
-   ${cta}
-──────────────────────────────────────`,
-      hint: 'suggest_compose',
-      actions: formatActions(actions.emptyInbox({
-        recentThreads: [],
-        recentShips,
-        onboardingTask
-      }))
+      display: `📭 No messages yet. ${cta}`,
+      actions: formatActions(actions.recommendedConnections([]))
     };
   }
 
-  // Sort: unread first, then by most recent
+  // Fetch relevant users to prioritize notifications
+  // Messages from relevant users appear first within unread threads
+  const relevantHandles = new Map(); // handle -> relevancy score (position in matches)
+  try {
+    const relevancy = await fetchRelevantUsers(myHandle, 'notification', 20);
+    if (relevancy && relevancy.matches) {
+      relevancy.matches.forEach((m, idx) => {
+        // Higher score = more relevant (inverse of position)
+        relevantHandles.set(m.handle.toLowerCase(), relevancy.matches.length - idx);
+      });
+    }
+  } catch (e) {
+    // Don't fail inbox if relevancy fails
+    console.log('[inbox] relevancy fetch error:', e.message);
+  }
+
+  // Sort: unread first, then by relevancy within unread, then by most recent
   const sorted = threads.sort((a, b) => {
+    // Primary: unread vs read
     if (a.unread > 0 && b.unread === 0) return -1;
     if (b.unread > 0 && a.unread === 0) return 1;
+
+    // Secondary (within same read/unread status): relevancy
+    const aRelevancy = relevantHandles.get(a.handle.toLowerCase()) || 0;
+    const bRelevancy = relevantHandles.get(b.handle.toLowerCase()) || 0;
+    if (aRelevancy !== bRelevancy) {
+      return bRelevancy - aRelevancy; // Higher relevancy first
+    }
+
+    // Tertiary: timestamp (most recent first)
     return (b.lastTimestamp || 0) - (a.lastTimestamp || 0);
   });
 
@@ -119,51 +213,141 @@ async function handler(args) {
 
   // Handle case where all messages are read (no unread)
   if (totalUnread === 0) {
-    const recentHandles = sorted.slice(0, 3).map(t => t.handle);
-    const recentDisplay = recentHandles.map(h => `@${h}`).join(', ');
-
-    // Fetch context for retention-optimized actions (parallel for speed)
-    const [recentShips, onboardingTask] = await Promise.all([
-      getRecentShips(2),
-      getNextOnboardingTask(myHandle)
-    ]);
-
-    // Build social proof line
-    let socialProof = '';
-    if (recentShips.length > 0) {
-      socialProof = `\n   💫 @${recentShips[0].author} just shipped`;
+    // Try to show personalized recommendations
+    try {
+      const recommendations = await buildRecommendationsDisplay(myHandle);
+      if (recommendations) {
+        return {
+          display: recommendations.display,
+          actions: recommendations.actions
+        };
+      }
+    } catch (e) {
+      console.log('[inbox] recommendations error:', e.message);
     }
 
-    // Track empty inbox state for retention analytics
-    analytics.trackEmptyInbox('none', {
-      recentThreads: recentHandles,
-      recentShips,
-      onboardingTask,
-      state: 'all_caught_up'
-    });
-
+    // Fallback: show recent threads
+    const recentHandles = sorted.slice(0, 3).map(t => `@${t.handle}`).join(', ');
     return {
-      display: `── 📭 Inbox ──────────────────────────
-   All caught up! Recent: ${recentDisplay}${socialProof}
-──────────────────────────────────────`,
-      hint: 'suggest_compose',
-      actions: formatActions(actions.emptyInbox({
-        recentThreads: recentHandles,
-        recentShips,
-        onboardingTask
-      }))
+      display: `📭 All caught up! Recent: ${recentHandles}`,
+      actions: formatActions(actions.recommendedConnections([]))
     };
   }
 
-  // Auto-open single unread message (skip inbox view to reduce friction)
+  // Auto-open single unread thread inline (no second tool call needed)
   if (totalUnread === 1 && unreadSenders.length === 1) {
-    const singleSender = unreadSenders[0];
-    return {
-      hint: 'auto_open_single_thread',
-      handle: singleSender.handle,
-      preview: truncate(singleSender.lastMessage || '', 60),
-      display: `📬 Opening thread with @${singleSender.handle}...`
-    };
+    const them = unreadSenders[0].handle;
+
+    // Fetch full thread and mark as read
+    const thread = await store.getThread(myHandle, them);
+    await store.markThreadRead(myHandle, them);
+
+    // Auto-track readWelcomeAt if viewing welcome from @seth
+    const isWelcomeThread = them.toLowerCase() === 'seth';
+    if (isWelcomeThread) {
+      try {
+        await store.trackChecklistCompletion(myHandle, 'read_welcome', {
+          source: 'inbox_auto_open',
+          timestamp: Date.now()
+        });
+        console.log('[inbox] Auto-tracked readWelcomeAt for', myHandle);
+      } catch (e) {
+        console.warn('[inbox] Failed to track readWelcomeAt:', e.message);
+      }
+    }
+
+    // Log received messages for patterns
+    const theirMessages = thread.filter(m => m.from === them);
+    if (theirMessages.length > 0) {
+      patterns.logMessageReceived(them);
+    }
+
+    // Check if they're typing
+    let typingNotice = '';
+    try {
+      const typingUsers = await store.getTypingUsers(myHandle);
+      if (typingUsers.includes(them)) {
+        typingNotice = `\n_@${them} is typing..._\n`;
+      }
+    } catch (e) {}
+
+    // Build thread display - summary first, newest-first thread
+    const latestFromThem = theirMessages.length > 0
+      ? theirMessages.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))[0]
+      : null;
+
+    let display = '';
+
+    if (latestFromThem) {
+      const agentBadge = latestFromThem.isAgent ? ' 🤖' : '';
+      const time = store.formatTimeAgo(latestFromThem.timestamp);
+      const preview = latestFromThem.body
+        ? summarizeMessage(latestFromThem.body)
+        : (latestFromThem.payload ? '[attachment]' : '');
+
+      display = `💬 @${them}${agentBadge} (${time}): "${preview}"\n\n`;
+    } else {
+      display = `💬 @${them}: _Waiting for reply..._\n\n`;
+    }
+
+    // Thread section - sorted newest first
+    display += `---\n📜 Thread\n\n`;
+
+    const sortedThread = [...thread].sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+
+    sortedThread.forEach(m => {
+      const isMe = m.from === myHandle;
+      const agentBadge = m.isAgent && !isMe ? '🤖 ' : '';
+      const sender = isMe ? 'you' : `@${m.from}`;
+      const time = store.formatTimeAgo(m.timestamp);
+
+      display += `${agentBadge}**${sender}** — _${time}_\n`;
+
+      if (m.body) {
+        display += `${m.body}\n`;
+      }
+
+      if (m.payload) {
+        display += `${formatPayload(m.payload)}\n`;
+      }
+
+      display += '\n';
+    });
+
+    if (typingNotice) {
+      display += typingNotice + '\n';
+    }
+
+    display += `---\nJust type your reply to send it`;
+
+    // For @seth welcome thread, fetch recommended builders and add actions
+    if (isWelcomeThread) {
+      try {
+        const onboardingData = await store.getOnboardingData(myHandle);
+        if (onboardingData.success && onboardingData.recommendedUsers?.length > 0) {
+          // Build action options to message recommended builders
+          const recommendedActions = onboardingData.recommendedUsers.slice(0, 3).map(user => {
+            const description = user.workingOn
+              ? `Building: "${truncate(user.workingOn, 40)}"`
+              : 'Recommended for you';
+            return {
+              handle: user.handle,
+              building: user.workingOn,
+              reasons: ['Matched during your welcome']
+            };
+          });
+
+          return {
+            display,
+            actions: formatActions(actions.recommendedConnections(recommendedActions))
+          };
+        }
+      } catch (e) {
+        console.warn('[inbox] Failed to fetch recommended builders:', e.message);
+      }
+    }
+
+    return { display };
   }
 
   // Build compact display (3 lines above the fold)