slashvibe-mcp 0.2.9 → 0.3.13

package/tools/inbox.js

@@ -5,9 +5,120 @@
 const config = require('../config');
 const store = require('../store');
 const notify = require('../notify');
-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');
 
+// 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) + '...';
+}
+
+// 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 presence = await store.getPresence();
+    const allUsers = [...(presence.active || []), ...(presence.away || [])];
+    allUsers.forEach(u => {
+      presenceMap.set(u.handle?.toLowerCase(), u);
+    });
+  } catch (e) {
+    // 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 = {
   name: 'vibe_inbox',
   description: 'See your unread messages and recent threads.',
@@ -28,39 +139,235 @@ async function handler(args) {
   notify.checkAll(store);
 
   if (!threads || threads.length === 0) {
+    // 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);
+    }
+
+    // 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: `${header('Inbox')}\n\n${emptyState('No messages yet.', 'Say "message someone" to start a conversation')}`
+      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);
   });
 
   const totalUnread = sorted.reduce((sum, t) => sum + (t.unread || 0), 0);
-  let display = header(`Inbox${totalUnread > 0 ? ` — ${totalUnread} UNREAD` : ''}`);
-  display += '\n\n';
-
-  sorted.forEach(thread => {
-    const unreadBadge = thread.unread > 0 ? ` 📬 NEW MESSAGE` : '';
-    const agentBadge = thread.isAgent ? '🤖 ' : '';
-    const preview = truncate(thread.lastMessage || '', 60);
-    const timeAgo = formatTimeAgo(thread.lastTimestamp);
-
-    display += `${agentBadge}**@${thread.handle}**${unreadBadge}\n`;
-    if (preview) {
-      display += `  "${preview}"\n`;
+  const unreadSenders = sorted.filter(t => t.unread > 0);
+
+  // Handle case where all messages are read (no unread)
+  if (totalUnread === 0) {
+    // 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);
     }
-    if (timeAgo) {
-      display += `  _${timeAgo}_\n`;
+
+    // Fallback: show recent threads
+    const recentHandles = sorted.slice(0, 3).map(t => `@${t.handle}`).join(', ');
+    return {
+      display: `📭 All caught up! Recent: ${recentHandles}`,
+      actions: formatActions(actions.recommendedConnections([]))
+    };
+  }
+
+  // Auto-open single unread thread inline (no second tool call needed)
+  if (totalUnread === 1 && unreadSenders.length === 1) {
+    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`;
     }
-    display += '\n';
-  });
 
-  display += `${divider()}Say "open thread with @handle" to read more`;
+    // 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)
+  // Line 1: Total count
+  let display = `📬 ${totalUnread} unread message${totalUnread > 1 ? 's' : ''}\n`;
+
+  // Line 2: Top 3 senders + overflow
+  const top3Names = unreadSenders.slice(0, 3).map(t => `@${t.handle}`);
+  const overflow = unreadSenders.length > 3 ? ` (+${unreadSenders.length - 3} more)` : '';
+  display += `from ${top3Names.join(', ')}${overflow}\n`;
+
+  // Line 3: Divider
+  display += '───────────────────────────────────\n';
+
+  // Line 4+: Expanded list with counts and badges
+  const expanded = unreadSenders.map(t => {
+    const agent = t.isAgent ? ' 🤖' : '';
+    return `@${t.handle} (${t.unread})${agent}`;
+  }).join(' • ');
+  display += expanded;
 
   // Build response with optional hints for structured flows
   const response = { display };
@@ -69,20 +376,19 @@ async function handler(args) {
   if (totalUnread >= 5) {
     response.hint = 'structured_triage_recommended';
     response.unread_count = totalUnread;
-    response.threads = sorted.filter(t => t.unread > 0).map(t => ({
+    response.threads = unreadSenders.map(t => ({
       handle: t.handle,
       unread: t.unread,
       preview: truncate(t.lastMessage || '', 40)
     }));
   }
-  // Suggest compose when inbox is empty or fully read
-  else if (threads.length === 0 || totalUnread === 0) {
-    response.hint = 'suggest_compose';
-  }
 
-  // Add guided mode actions
-  const threadSummaries = sorted.slice(0, 4).map(t => ({ handle: t.handle, unread: t.unread || 0 }));
-  response.actions = formatActions(actions.afterInbox(threadSummaries));
+  // Add guided mode actions with compact format
+  const senderSummaries = unreadSenders.map(t => ({
+    handle: t.handle,
+    unread: t.unread || 0
+  }));
+  response.actions = formatActions(actions.afterInboxCompact(senderSummaries));
 
   return response;
 }