slashvibe-mcp 0.3.20 → 0.3.21

package/tools/discover.js

@@ -2,8 +2,9 @@
  * vibe discover — Find your people
  *
  * Smart matchmaking based on:
+ * - Social connections (X/GitHub mutual follows)
  * - What you're building (similar projects)
- * - What you've shipped (complementary skills)  
+ * - What you've shipped (complementary skills)
  * - When you're active (timezone overlap)
  * - Shared interests (tags)
  *
@@ -12,23 +13,115 @@
  * - discover search <query> — Find people building specific things
  * - discover interests — Browse people by interest tags
  * - discover active — Show who's building similar things right now
+ *
+ * Uses Universal Relevancy API for smart matching with social-first signals.
+ * Falls back to local matching if API unavailable.
  */
 
 const config = require('../config');
 const store = require('../store');
 const userProfiles = require('../store/profiles');
 const { formatTimeAgo, requireInit } = require('./_shared');
+const { getTechTags, getTechOneLiner } = require('../lib/tech-detection');
+
+// API configuration
+const RELEVANCY_API = 'https://www.slashvibe.dev/api/relevancy';
+const API_TIMEOUT = 5000; // 5 seconds
+
+// Detect current project tech stack for better matching
+let cachedTechStack = null;
+let techStackCacheTime = 0;
+const TECH_CACHE_TTL = 60000; // 1 minute cache
+
+function getCurrentTechStack() {
+  const now = Date.now();
+  if (cachedTechStack && (now - techStackCacheTime) < TECH_CACHE_TTL) {
+    return cachedTechStack;
+  }
+  try {
+    cachedTechStack = {
+      tags: getTechTags(),
+      oneLiner: getTechOneLiner(),
+    };
+    techStackCacheTime = now;
+  } catch (e) {
+    cachedTechStack = { tags: [], oneLiner: '' };
+  }
+  return cachedTechStack;
+}
+
+/**
+ * Fetch suggestions from Universal Relevancy API
+ * Uses social signals (GitHub mutuals, etc.) for better matching
+ *
+ * @param {string} handle - User's vibe handle
+ * @param {number} limit - Max results (default 5)
+ * @returns {Promise<{ matches: object[], tier: string, fromApi: boolean } | null>}
+ */
+async function fetchApiSuggestions(handle, limit = 5) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), API_TIMEOUT);
+
+    // Include current project tech stack for better matching
+    const techStack = getCurrentTechStack();
+    const techTags = techStack.tags.join(',');
+
+    let url = `${RELEVANCY_API}?handle=${encodeURIComponent(handle)}&context=discovery&limit=${limit}`;
+    if (techTags) {
+      url += `&tech_tags=${encodeURIComponent(techTags)}`;
+    }
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+        'User-Agent': 'vibe-mcp-client'
+      },
+      signal: controller.signal
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      console.log(`[discover] API returned ${response.status}`);
+      return null;
+    }
+
+    const data = await response.json();
+
+    if (!data.success || !data.matches) {
+      console.log('[discover] API returned unsuccessful response');
+      return null;
+    }
+
+    return {
+      matches: data.matches,
+      tier: data.tier,
+      socialStats: data.socialStats,
+      fromApi: true
+    };
+  } catch (e) {
+    // Log but don't fail - we'll fallback to local
+    if (e.name === 'AbortError') {
+      console.log('[discover] API timeout, falling back to local');
+    } else {
+      console.log('[discover] API error:', e.message);
+    }
+    return null;
+  }
+}
 
 const definition = {
   name: 'vibe_discover',
-  description: 'Find interesting people to connect with based on what they\'re building.',
+  description: 'Find interesting people to connect with, see who\'s live, browse upcoming sessions.',
   inputSchema: {
     type: 'object',
     properties: {
       command: {
         type: 'string',
-        enum: ['suggest', 'search', 'interests', 'active'],
-        description: 'Discovery command to run'
+        enum: ['suggest', 'search', 'interests', 'active', 'live', 'upcoming', 'sessions', 'creators'],
+        description: 'Discovery command: suggest, search, interests, active, live, upcoming, sessions, creators'
       },
       query: {
         type: 'string',
@@ -38,6 +131,34 @@ const definition = {
   }
 };
 
+// Format duration in seconds to human readable
+function formatDuration(seconds) {
+  if (!seconds || seconds < 60) return '<1m';
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+}
+
+// Format scheduled time to relative string
+function formatScheduledTime(isoString) {
+  const date = new Date(isoString);
+  const now = new Date();
+  const diffMs = date - now;
+  const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+  const diffDays = Math.floor(diffHours / 24);
+
+  if (diffMs < 0) return 'started';
+  if (diffDays === 0) {
+    if (diffHours <= 1) return 'in < 1 hour';
+    return `in ${diffHours} hours`;
+  } else if (diffDays === 1) {
+    return 'tomorrow';
+  } else {
+    return `in ${diffDays} days`;
+  }
+}
+
 // Calculate match score between two users
 function calculateMatchScore(user1, user2) {
   let score = 0;
@@ -132,11 +253,12 @@ function findComplementaryTags(tags1, tags2) {
   return complementary;
 }
 
-// Get personalized suggestions
-async function getSuggestions(myHandle) {
+// Get personalized suggestions (local fallback)
+// This is used when API is unavailable
+async function getLocalSuggestions(myHandle) {
   const myProfile = await userProfiles.getProfile(myHandle);
   const allProfiles = await userProfiles.getAllProfiles();
-  
+
   const candidates = allProfiles.filter(p => p.handle !== myHandle);
   const matches = [];
 
@@ -158,6 +280,28 @@ async function getSuggestions(myHandle) {
   return matches.sort((a, b) => b.score - a.score).slice(0, 5);
 }
 
+/**
+ * Get suggestions - tries API first, falls back to local
+ * @param {string} myHandle - User's handle
+ * @returns {Promise<{ matches: object[], fromApi: boolean, tier?: string }>}
+ */
+async function getSuggestions(myHandle) {
+  // Try API first (has social signals, better matching)
+  const apiResult = await fetchApiSuggestions(myHandle, 5);
+
+  if (apiResult && apiResult.matches.length > 0) {
+    return apiResult;
+  }
+
+  // Fallback to local matching
+  const localMatches = await getLocalSuggestions(myHandle);
+  return {
+    matches: localMatches,
+    fromApi: false,
+    tier: 'local'
+  };
+}
+
 // Search for people by query
 async function searchPeople(query) {
   const allProfiles = await userProfiles.getAllProfiles();
@@ -237,41 +381,68 @@ async function handler(args) {
   try {
     switch (command) {
       case 'suggest': {
-        const suggestions = await getSuggestions(myHandle);
-        
-        if (suggestions.length === 0) {
+        const result = await getSuggestions(myHandle);
+        const { matches, fromApi, tier } = result;
+
+        if (!matches || matches.length === 0) {
           display = `## No Matches Found
 
 _Not enough people with profiles yet._
 
 **Help us learn about you:**
-- Set interests: \`vibe update interests "ai, startups, music"\`  
+- Set interests: \`vibe update interests "ai, startups, music"\`
 - Tag your skills: \`vibe update tags "frontend, react, typescript"\`
 - Share what you're building: \`vibe update building "AI chat app"\`
 
 The more people share, the better our matches become!`;
         } else {
-          display = `## People You Should Meet\n\n`;
-          
-          for (const match of suggestions) {
-            display += `**@${match.handle}** _(${match.score} match)_\n`;
+          // Title varies by result tier
+          if (tier === 'contextual' || tier === 'mixed') {
+            display = `## 🔍 Suggested Connections\n\n`;
+          } else if (tier === 'trending') {
+            display = `## 🔥 Trending Builders\n\n`;
+          } else if (tier === 'new_joiners') {
+            display = `## 👋 New to /vibe\n\n`;
+          } else {
+            display = `## People You Should Meet\n\n`;
+          }
+
+          // Show detected tech stack if any
+          const techStack = getCurrentTechStack();
+          if (techStack.oneLiner) {
+            display += `_Matching for: ${techStack.oneLiner}_\n\n`;
+          }
+
+          for (const match of matches) {
+            // Handle name with optional tier badge
+            const tierBadge = match.tierEmoji ? ` ${match.tierEmoji}` : '';
+            display += `**@${match.handle}**${tierBadge}\n`;
             display += `${match.building || 'Building something interesting'}\n`;
-            
-            if (match.reasons.length > 0) {
-              display += `🔗 ${match.reasons.join(' • ')}\n`;
+
+            // Show reasons as a tree structure (from API)
+            if (match.reasons && match.reasons.length > 0) {
+              for (let i = 0; i < match.reasons.length; i++) {
+                const prefix = i === match.reasons.length - 1 ? '└─' : '├─';
+                display += `  ${prefix} ${match.reasons[i]}\n`;
+              }
             }
-            
-            if (match.interests.length > 0) {
+            // Fallback for local matches (has interests array)
+            else if (match.interests && match.interests.length > 0) {
               display += `💡 ${match.interests.slice(0, 3).join(', ')}\n`;
             }
-            
-            display += `_Last seen: ${formatTimeAgo(match.lastSeen)}_\n\n`;
+
+            display += '\n';
           }
-          
+
           display += `**Next steps:**\n`;
           display += `- \`message @handle\` to reach out\n`;
           display += `- \`discover active\` to see who's online now\n`;
           display += `- \`discover search <topic>\` to find specific interests`;
+
+          // Debug info (only in dev)
+          if (process.env.VIBE_DEBUG === 'true') {
+            display += `\n\n_Source: ${fromApi ? 'API' : 'local'} | Tier: ${tier}_`;
+          }
         }
         break;
       }
@@ -339,7 +510,7 @@ People haven't shared their interests yet.
 
       case 'active': {
         const similar = await getActiveSimilar(myHandle);
-        
+
         if (similar.length === 0) {
           display = `## No Similar Builders Online
 
@@ -347,38 +518,183 @@ No one with similar interests is active right now.
 
 **Try:**
 - \`who\` to see who's around
-- \`discover suggest\` for general recommendations  
+- \`discover suggest\` for general recommendations
 - \`discover search <topic>\` to find people by interest`;
         } else {
           display = `## Similar Builders Online Now\n\n`;
-          
+
           for (const person of similar) {
             display += `**@${person.handle}** _(${person.status})_\n`;
             display += `${person.building || person.one_liner || 'Active now'}\n`;
-            
+
             if (person.reasons.length > 0) {
               display += `🔗 ${person.reasons.join(' • ')}\n`;
             }
-            
+
             display += `\n`;
           }
-          
+
           display += `**Perfect time to connect!** 🎯`;
         }
         break;
       }
 
+      case 'live': {
+        // Fetch live broadcasts from discover API
+        const apiUrl = config.getApiUrl();
+        const response = await fetch(`${apiUrl}/api/discover?section=live`);
+        const data = await response.json();
+
+        if (!data.success || !data.live || data.live.length === 0) {
+          display = `## No One Live Right Now
+
+_Check back later or schedule your own session!_
+
+**Go live:** \`vibe broadcast start "What you're building"\`
+**See upcoming:** \`vibe discover upcoming\``;
+        } else {
+          display = `## 🔴 Live Now\n\n`;
+
+          for (const broadcast of data.live) {
+            const duration = formatDuration(broadcast.durationSeconds);
+            display += `**@${broadcast.handle}** — ${broadcast.title}\n`;
+            display += `👥 ${broadcast.viewerCount} watching · ⏱️ ${duration}`;
+            if (broadcast.reactionCount > 0) {
+              display += ` · 🔥 ${broadcast.reactionCount}`;
+            }
+            display += `\n`;
+            display += `[Watch](${broadcast.watchUrl})\n\n`;
+          }
+
+          display += `---\n`;
+          display += `\`vibe watch @handle\` to tune in`;
+        }
+        break;
+      }
+
+      case 'upcoming': {
+        const apiUrl = config.getApiUrl();
+        const response = await fetch(`${apiUrl}/api/discover?section=scheduled`);
+        const data = await response.json();
+
+        if (!data.success || !data.scheduled || data.scheduled.length === 0) {
+          display = `## No Scheduled Sessions
+
+_No one has scheduled a session yet._
+
+**Schedule yours:** \`vibe schedule "Topic" --time "tomorrow 3pm"\`
+**See who's live:** \`vibe discover live\``;
+        } else {
+          display = `## 📅 Upcoming Sessions\n\n`;
+
+          for (const session of data.scheduled) {
+            const when = formatScheduledTime(session.scheduledFor);
+            display += `**${session.title}**\n`;
+            display += `@${session.handle} · ${when}`;
+            if (session.rsvpCount > 0) {
+              display += ` · ${session.rsvpCount} RSVPs`;
+            }
+            display += `\n`;
+            if (session.tags && session.tags.length > 0) {
+              display += `🏷️ ${session.tags.join(', ')}\n`;
+            }
+            display += `\n`;
+          }
+
+          display += `---\n`;
+          display += `\`vibe schedule rsvp <id>\` to get notified`;
+        }
+        break;
+      }
+
+      case 'sessions': {
+        const apiUrl = config.getApiUrl();
+        const response = await fetch(`${apiUrl}/api/discover?section=sessions`);
+        const data = await response.json();
+
+        if (!data.success || !data.recentSessions || data.recentSessions.length === 0) {
+          display = `## No Recent Sessions
+
+_No recorded sessions yet._
+
+**Record yours:** After broadcasting, use \`vibe session save\``;
+        } else {
+          display = `## 📼 Recent Sessions\n\n`;
+
+          for (const session of data.recentSessions) {
+            display += `**${session.title}**\n`;
+            display += `@${session.handle}`;
+            if (session.views > 0) {
+              display += ` · ${session.views} views`;
+            }
+            if (session.duration) {
+              display += ` · ${formatDuration(session.duration)}`;
+            }
+            display += `\n`;
+            if (session.tags && session.tags.length > 0) {
+              display += `🏷️ ${session.tags.join(', ')}\n`;
+            }
+            display += `\n`;
+          }
+
+          display += `---\n`;
+          display += `\`vibe session view <id>\` to watch`;
+        }
+        break;
+      }
+
+      case 'creators': {
+        const apiUrl = config.getApiUrl();
+        const response = await fetch(`${apiUrl}/api/discover?handle=${myHandle}&section=recommended`);
+        const data = await response.json();
+
+        if (!data.success || !data.recommended || data.recommended.length === 0) {
+          display = `## Recommended Creators
+
+_Not enough data yet to make recommendations._
+
+**Try:**
+- \`vibe discover suggest\` — Find people by interests
+- \`vibe discover active\` — See who's online now`;
+        } else {
+          display = `## 👤 Recommended Creators\n\n`;
+
+          for (const creator of data.recommended) {
+            display += `**@${creator.handle}**`;
+            if (creator.followerCount > 0) {
+              display += ` (${creator.followerCount} followers)`;
+            }
+            display += `\n`;
+            if (creator.building) {
+              display += `${creator.building}\n`;
+            }
+            display += `_${creator.reason}_\n\n`;
+          }
+
+          display += `---\n`;
+          display += `\`vibe follow @handle\` to follow`;
+        }
+        break;
+      }
+
       default:
         display = `## Discovery Commands
 
-**\`discover suggest\`** — Get personalized recommendations
-**\`discover search <query>\`** — Find people building specific things  
-**\`discover interests\`** — Browse people by interest tags
-**\`discover active\`** — Show who's building similar things right now
+**Live & Sessions:**
+- \`discover live\` — See who's broadcasting now
+- \`discover upcoming\` — Browse scheduled sessions
+- \`discover sessions\` — Watch recent recorded sessions
+
+**Find People:**
+- \`discover suggest\` — Get personalized recommendations
+- \`discover creators\` — Popular creators to follow
+- \`discover search <query>\` — Find people building specific things
+- \`discover interests\` — Browse people by interest tags
+- \`discover active\` — Who's building similar things right now
 
 **Set up your profile:**
 - \`vibe update building "what you're working on"\`
-- \`vibe update interests "ai, startups, music"\`  
+- \`vibe update interests "ai, startups, music"\`
 - \`vibe update tags "frontend, react, typescript"\``;
     }
   } catch (error) {

package/tools/dm.js

@@ -8,12 +8,12 @@ const memory = require('../memory');
 const userProfiles = require('../store/profiles');
 const patterns = require('../intelligence/patterns');
 const { trackMessage, checkBurst } = require('./summarize');
-const { requireInit, normalizeHandle, truncate, warning } = require('./_shared');
+const { requireInit, normalizeHandle, truncate, warning, fetchRelevantUsers } = require('./_shared');
 const { actions, formatActions } = require('./_actions');
 
 const definition = {
   name: 'vibe_dm',
-  description: 'Send a direct message to someone. Can include structured payload for games, handoffs, or artifact cards.',
+  description: 'Send a direct message to someone. Can include structured payload for games, handoffs, artifact cards, or an instant USDC tip.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -32,6 +32,14 @@ const definition = {
       payload: {
         type: 'object',
         description: 'Optional structured data (game state, code review, handoff, etc.)'
+      },
+      reply_to: {
+        type: 'string',
+        description: 'Optional: Message ID to reply to (creates a threaded reply)'
+      },
+      tip_amount_cents: {
+        type: 'number',
+        description: 'Optional: Attach an instant USDC tip (100 = $1, 500 = $5, 1000 = $10)'
       }
     },
     required: ['handle']
@@ -42,7 +50,7 @@ async function handler(args) {
   const initCheck = requireInit();
   if (initCheck) return initCheck;
 
-  const { handle, message, artifact_slug, payload } = args;
+  const { handle, message, artifact_slug, payload, reply_to, tip_amount_cents } = args;
   const myHandle = config.getHandle();
   const them = normalizeHandle(handle);
 
@@ -87,7 +95,13 @@ async function handler(args) {
   const wasTruncated = trimmed.length > MAX_LENGTH;
   const finalMessage = wasTruncated ? trimmed.substring(0, MAX_LENGTH) : trimmed;
 
-  const result = await store.sendMessage(myHandle, them, finalMessage || null, 'dm', finalPayload);
+  // Send typing indicator (shows "typing..." to recipient while message is being sent)
+  // Non-blocking - we don't wait for this
+  store.sendTypingIndicator(myHandle, them).catch(() => {});
+
+  const result = await store.sendMessage(myHandle, them, finalMessage || null, 'dm', finalPayload, {
+    replyTo: reply_to || null,
+  });
 
   // Check for errors
   if (result && result.error) {
@@ -121,10 +135,7 @@ async function handler(args) {
     display += ` ${warning(`truncated to ${MAX_LENGTH} chars`)}`;
   }
 
-  // Show message preview or payload type
-  if (finalMessage) {
-    display += `\n\n"${truncate(finalMessage, 100)}"`;
-  }
+  // Only show payload type indicator (message already visible in tool call)
   if (finalPayload) {
     const payloadType = finalPayload.type || 'data';
     if (payloadType === 'artifact') {
@@ -135,6 +146,47 @@ async function handler(args) {
     }
   }
 
+  // Execute attached tip if specified
+  let tipResult = null;
+  if (tip_amount_cents && tip_amount_cents > 0) {
+    const token = config.getToken();
+    if (token) {
+      try {
+        const apiUrl = config.getApiUrl();
+        // Generate idempotency key to prevent duplicate tips from retries
+        const timeBucket = Math.floor(Date.now() / 60000);
+        const tipIdempotencyKey = `dm:${myHandle}:${them}:${tip_amount_cents}:${timeBucket}`;
+
+        const tipResponse = await fetch(`${apiUrl}/api/tips/instant`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+            'Idempotency-Key': tipIdempotencyKey
+          },
+          body: JSON.stringify({
+            to: them,
+            amount_cents: tip_amount_cents,
+            message: message ? `${message.substring(0, 50)}...` : null,
+            context: { type: 'dm_reply' }
+          })
+        });
+
+        tipResult = await tipResponse.json();
+
+        if (tipResult.success) {
+          const tipAmount = (tip_amount_cents / 100).toFixed(0);
+          display += `\n\n💸 _Tipped $${tipAmount} USDC — [view tx](${tipResult.explorer_url})_`;
+        } else {
+          display += `\n\n⚠️ _Tip failed: ${tipResult.message || 'Unknown error'}_`;
+        }
+      } catch (tipError) {
+        console.warn('[dm] Tip execution failed:', tipError.message);
+        display += `\n\n⚠️ _Tip failed: ${tipError.message}_`;
+      }
+    }
+  }
+
   // Burst notification (5+ messages in one thread)
   if (burst.triggered && burst.thread === them) {
     display += `\n\n💬 _${burst.count} messages with @${them} — say "summarize" when done_`;
@@ -162,6 +214,26 @@ async function handler(args) {
   // Add guided mode actions
   response.actions = formatActions(actions.afterDm(them));
 
+  // Fetch DM suggestions (async, non-blocking for response)
+  // This adds "You might want to message..." suggestions
+  try {
+    const suggestions = await fetchRelevantUsers(myHandle, 'dm_suggest', 3);
+    if (suggestions && suggestions.matches && suggestions.matches.length > 0) {
+      // Filter out the person we just messaged
+      const others = suggestions.matches.filter(m => m.handle !== them);
+      if (others.length > 0) {
+        response.dm_suggestions = others.map(m => ({
+          handle: m.handle,
+          building: m.building,
+          reasons: m.reasons?.slice(0, 2) || []
+        }));
+      }
+    }
+  } catch (e) {
+    // Don't fail DM if suggestions fail
+    console.log('[dm] dm_suggest fetch error:', e.message);
+  }
+
   return response;
 }