slashvibe-mcp 0.2.9 → 0.3.13

package/tools/_deprecated/discovery-analytics.js

@@ -0,0 +1,345 @@
+/**
+ * vibe discovery-analytics — Community Discovery Insights
+ *
+ * Provides analytics and insights about the /vibe community to help
+ * understand connection patterns, popular interests, and opportunities
+ * for better matching.
+ *
+ * Commands:
+ * - discovery-analytics overview — Community overview and trends
+ * - discovery-analytics gaps — Identify connection opportunities  
+ * - discovery-analytics popular — Most popular interests and skills
+ * - discovery-analytics lonely — People who might need connections
+ */
+
+const config = require('../config');
+const userProfiles = require('../store/profiles');
+const { formatTimeAgo, requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_discovery_analytics',
+  description: 'Analytics and insights about community discovery patterns.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      command: {
+        type: 'string',
+        enum: ['overview', 'gaps', 'popular', 'lonely'],
+        description: 'Analytics command to run'
+      }
+    }
+  }
+};
+
+// Calculate community health metrics
+async function getCommunityHealth() {
+  const profiles = await userProfiles.getAllProfiles();
+  const totalUsers = profiles.length;
+  
+  // Profile completeness
+  const withBuilding = profiles.filter(p => p.building).length;
+  const withInterests = profiles.filter(p => p.interests && p.interests.length > 0).length;
+  const withTags = profiles.filter(p => p.tags && p.tags.length > 0).length;
+  const withConnections = profiles.filter(p => p.connections && p.connections.length > 0).length;
+  
+  // Activity levels
+  const now = Date.now();
+  const day = 24 * 60 * 60 * 1000;
+  const week = 7 * day;
+  
+  const activeToday = profiles.filter(p => p.lastSeen && (now - p.lastSeen) < day).length;
+  const activeThisWeek = profiles.filter(p => p.lastSeen && (now - p.lastSeen) < week).length;
+  
+  return {
+    totalUsers,
+    profileCompleteness: {
+      withBuilding: Math.round((withBuilding / totalUsers) * 100),
+      withInterests: Math.round((withInterests / totalUsers) * 100),
+      withTags: Math.round((withTags / totalUsers) * 100),
+      withConnections: Math.round((withConnections / totalUsers) * 100)
+    },
+    activity: {
+      activeToday,
+      activeThisWeek,
+      todayRate: Math.round((activeToday / totalUsers) * 100),
+      weekRate: Math.round((activeThisWeek / totalUsers) * 100)
+    }
+  };
+}
+
+// Find potential connection gaps
+async function findConnectionGaps() {
+  const profiles = await userProfiles.getAllProfiles();
+  const gaps = [];
+  
+  // Find isolated users (no connections)
+  const isolated = profiles.filter(p => !p.connections || p.connections.length === 0);
+  
+  // Find skill gaps (people with complementary skills who haven't connected)
+  const skillPairs = [
+    ['frontend', 'backend'],
+    ['design', 'engineering'],
+    ['ai', 'data'],
+    ['product', 'engineering'],
+    ['research', 'implementation'],
+    ['marketing', 'product']
+  ];
+  
+  const missedConnections = [];
+  for (const [skill1, skill2] of skillPairs) {
+    const group1 = profiles.filter(p => p.tags?.includes(skill1));
+    const group2 = profiles.filter(p => p.tags?.includes(skill2));
+    
+    for (const user1 of group1) {
+      for (const user2 of group2) {
+        if (user1.handle !== user2.handle) {
+          const connected = await userProfiles.hasBeenConnected(user1.handle, user2.handle);
+          if (!connected) {
+            missedConnections.push({
+              user1: user1.handle,
+              user2: user2.handle,
+              reason: `${skill1} + ${skill2} collaboration potential`,
+              user1Building: user1.building,
+              user2Building: user2.building
+            });
+          }
+        }
+      }
+    }
+  }
+  
+  return {
+    isolated: isolated.slice(0, 5),
+    missedConnections: missedConnections.slice(0, 8)
+  };
+}
+
+// Find people who might need more connections
+async function findLonelyUsers() {
+  const profiles = await userProfiles.getAllProfiles();
+  const now = Date.now();
+  const week = 7 * 24 * 60 * 60 * 1000;
+  
+  const lonely = profiles.filter(p => {
+    const recentlyActive = p.lastSeen && (now - p.lastSeen) < week;
+    const hasProfile = p.building || (p.interests && p.interests.length > 0);
+    const fewConnections = !p.connections || p.connections.length < 2;
+    
+    return recentlyActive && hasProfile && fewConnections;
+  });
+  
+  return lonely.sort((a, b) => (b.lastSeen || 0) - (a.lastSeen || 0)).slice(0, 5);
+}
+
+// Analyze interest and skill trends
+async function analyzePopularTrends() {
+  const trendingInterests = await userProfiles.getTrendingInterests();
+  const trendingTags = await userProfiles.getTrendingTags();
+  
+  // Calculate growth potential
+  const profiles = await userProfiles.getAllProfiles();
+  const interestCombos = {};
+  
+  for (const profile of profiles) {
+    if (profile.interests && profile.interests.length > 1) {
+      for (let i = 0; i < profile.interests.length; i++) {
+        for (let j = i + 1; j < profile.interests.length; j++) {
+          const combo = [profile.interests[i], profile.interests[j]].sort().join(' + ');
+          interestCombos[combo] = (interestCombos[combo] || 0) + 1;
+        }
+      }
+    }
+  }
+  
+  const topCombos = Object.entries(interestCombos)
+    .sort(([,a], [,b]) => b - a)
+    .slice(0, 5)
+    .map(([combo, count]) => ({ combo, count }));
+  
+  return {
+    interests: trendingInterests,
+    skills: trendingTags,
+    interestCombos: topCombos
+  };
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const command = args.command || 'overview';
+  let display = '';
+
+  try {
+    switch (command) {
+      case 'overview': {
+        const health = await getCommunityHealth();
+        const trends = await analyzePopularTrends();
+        
+        display = `## /vibe Discovery Analytics 📊\n\n`;
+        
+        display += `### Community Health\n`;
+        display += `**Total Users:** ${health.totalUsers}\n`;
+        display += `**Active Today:** ${health.activity.activeToday} (${health.activity.todayRate}%)\n`;
+        display += `**Active This Week:** ${health.activity.activeThisWeek} (${health.activity.weekRate}%)\n\n`;
+        
+        display += `### Profile Completeness\n`;
+        display += `**Building Projects:** ${health.profileCompleteness.withBuilding}%\n`;
+        display += `**Have Interests:** ${health.profileCompleteness.withInterests}%\n`;
+        display += `**Have Skills:** ${health.profileCompleteness.withTags}%\n`;
+        display += `**Made Connections:** ${health.profileCompleteness.withConnections}%\n\n`;
+        
+        display += `### Trending Now\n`;
+        if (trends.interests.length > 0) {
+          display += `**Top Interests:** ${trends.interests.slice(0, 3).map(i => `${i.interest} (${i.count})`).join(', ')}\n`;
+        }
+        if (trends.skills.length > 0) {
+          display += `**Hot Skills:** ${trends.skills.slice(0, 3).map(s => `${s.tag} (${s.count})`).join(', ')}\n`;
+        }
+        
+        if (trends.interestCombos.length > 0) {
+          display += `**Interest Combos:** ${trends.interestCombos.slice(0, 2).map(c => c.combo).join(', ')}\n`;
+        }
+        
+        display += `\n**Commands:**\n`;
+        display += `• \`discovery-analytics gaps\` — Find connection opportunities\n`;
+        display += `• \`discovery-analytics popular\` — See detailed trends\n`;
+        display += `• \`discovery-analytics lonely\` — People who need connections`;
+        break;
+      }
+
+      case 'gaps': {
+        const gaps = await findConnectionGaps();
+        
+        display = `## Connection Opportunities 🔗\n\n`;
+        
+        if (gaps.isolated.length > 0) {
+          display += `### New Users Need Connections\n`;
+          for (const user of gaps.isolated) {
+            display += `**@${user.handle}**\n`;
+            display += `${user.building || 'Ready to connect'}\n`;
+            if (user.interests && user.interests.length > 0) {
+              display += `Interests: ${user.interests.join(', ')}\n`;
+            }
+            if (user.tags && user.tags.length > 0) {
+              display += `Skills: ${user.tags.join(', ')}\n`;
+            }
+            display += `_Last seen: ${formatTimeAgo(user.lastSeen)}_\n\n`;
+          }
+        }
+        
+        if (gaps.missedConnections.length > 0) {
+          display += `### Missed Collaboration Opportunities\n`;
+          for (const missed of gaps.missedConnections.slice(0, 5)) {
+            display += `**@${missed.user1}** + **@${missed.user2}**\n`;
+            display += `${missed.reason}\n`;
+            if (missed.user1Building) display += `• ${missed.user1}: ${missed.user1Building}\n`;
+            if (missed.user2Building) display += `• ${missed.user2}: ${missed.user2Building}\n`;
+            display += `\n`;
+          }
+          
+          display += `**Suggest these connections:**\n`;
+          display += `\`suggest-connection @${gaps.missedConnections[0].user1} @${gaps.missedConnections[0].user2} "${gaps.missedConnections[0].reason}"\``;
+        }
+        
+        if (gaps.isolated.length === 0 && gaps.missedConnections.length === 0) {
+          display = `## All Connected! 🎉\n\nNo obvious connection gaps found. The community is well-connected!\n\n**Keep growing:**\n• Encourage more profile completion\n• Watch for new joiners to welcome`;
+        }
+        break;
+      }
+
+      case 'popular': {
+        const trends = await analyzePopularTrends();
+        
+        display = `## Community Trends 📈\n\n`;
+        
+        if (trends.interests.length > 0) {
+          display += `### Popular Interests\n`;
+          for (const trend of trends.interests) {
+            display += `**${trend.interest}** — ${trend.count} people\n`;
+          }
+          display += `\n`;
+        }
+        
+        if (trends.skills.length > 0) {
+          display += `### Top Skills\n`;
+          for (const skill of trends.skills) {
+            display += `**${skill.tag}** — ${skill.count} people\n`;
+          }
+          display += `\n`;
+        }
+        
+        if (trends.interestCombos.length > 0) {
+          display += `### Interest Combinations\n`;
+          for (const combo of trends.interestCombos) {
+            display += `**${combo.combo}** — ${combo.count} people\n`;
+          }
+          display += `\n`;
+        }
+        
+        display += `**Discovery Opportunities:**\n`;
+        display += `• Create interest groups for popular topics\n`;
+        display += `• Host skill-sharing sessions\n`;
+        display += `• Encourage rare skill/interest combinations`;
+        break;
+      }
+
+      case 'lonely': {
+        const lonely = await findLonelyUsers();
+        
+        if (lonely.length === 0) {
+          display = `## Everyone's Connected! 🤝\n\nNo lonely users found. The community is doing great at connecting!\n\n**Keep it up:**\n• Welcome new joiners quickly\n• Encourage profile completion\n• Celebrate successful connections`;
+        } else {
+          display = `## People Who Could Use More Connections\n\n`;
+          
+          for (const user of lonely) {
+            display += `**@${user.handle}**\n`;
+            display += `${user.building || 'Available to connect'}\n`;
+            
+            if (user.interests && user.interests.length > 0) {
+              display += `Interests: ${user.interests.join(', ')}\n`;
+            }
+            
+            if (user.tags && user.tags.length > 0) {
+              display += `Skills: ${user.tags.join(', ')}\n`;
+            }
+            
+            const connectionCount = (user.connections || []).length;
+            display += `Connections: ${connectionCount}\n`;
+            display += `_Last seen: ${formatTimeAgo(user.lastSeen)}_\n\n`;
+          }
+          
+          display += `**Suggested Actions:**\n`;
+          display += `• Proactively introduce them to similar builders\n`;
+          display += `• Include them in group conversations\n`;
+          display += `• Share their projects on the board`;
+        }
+        break;
+      }
+
+      default:
+        display = `## Discovery Analytics Commands
+
+**\`discovery-analytics overview\`** — Community health and trends
+**\`discovery-analytics gaps\`** — Find connection opportunities  
+**\`discovery-analytics popular\`** — Most popular interests and skills
+**\`discovery-analytics lonely\`** — People who might need connections
+
+**Use these insights to:**
+- Identify people who need connections
+- Find missed collaboration opportunities  
+- Understand community trends
+- Guide future discovery improvements`;
+    }
+  } catch (error) {
+    display = `## Analytics Error
+
+${error.message}
+
+Try: \`discovery-analytics\` for available commands`;
+  }
+
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/_deprecated/discovery-auto-suggest.js

@@ -0,0 +1,275 @@
+/**
+ * Discovery Auto Suggest — Intelligent automatic connection suggestions
+ *
+ * This tool runs automatically when the discovery agent is active to:
+ * - Find high-quality matches based on recent activity
+ * - Send personalized connection suggestions
+ * - Track suggestion success rates
+ * - Optimize timing for better engagement
+ */
+
+const config = require('../config');
+const userProfiles = require('../store/profiles');
+const store = require('../store');
+const { formatTimeAgo } = require('./_shared');
+const smartIntro = require('./smart-intro');
+
+// Calculate enhanced match score with behavioral signals
+function calculateEnhancedMatchScore(user1, user2) {
+  let score = 0;
+  const reasons = [];
+  
+  // Core similarity scoring
+  if (user1.interests && user2.interests) {
+    const shared = user1.interests.filter(i => 
+      user2.interests.some(j => i.toLowerCase() === j.toLowerCase())
+    );
+    if (shared.length > 0) {
+      score += shared.length * 15;
+      reasons.push(`Shared interests: ${shared.slice(0, 2).join(', ')}`);
+    }
+  }
+  
+  if (user1.tags && user2.tags) {
+    const sharedTags = user1.tags.filter(t => 
+      user2.tags.some(u => t.toLowerCase() === u.toLowerCase())
+    );
+    if (sharedTags.length > 0) {
+      score += sharedTags.length * 12;
+      reasons.push(`Similar skills: ${sharedTags.slice(0, 2).join(', ')}`);
+    }
+  }
+  
+  // Building similarity
+  if (user1.building && user2.building) {
+    const building1 = user1.building.toLowerCase();
+    const building2 = user2.building.toLowerCase();
+    const words1 = building1.split(/\s+/);
+    const words2 = building2.split(/\s+/);
+    const overlap = words1.filter(w => words2.includes(w) && w.length > 3);
+    if (overlap.length > 0) {
+      score += overlap.length * 10;
+      reasons.push(`Both working on ${overlap[0]}`);
+    }
+  }
+  
+  // Complementary skills bonus
+  const complementaryPairs = [
+    [['frontend', 'react', 'ui'], ['backend', 'api', 'server']],
+    [['design', 'figma', 'ui'], ['frontend', 'development']],
+    [['ai', 'ml'], ['data', 'python', 'backend']],
+    [['product', 'pm'], ['engineering', 'technical']],
+    [['mobile', 'ios', 'android'], ['backend', 'api']]
+  ];
+  
+  for (const [group1, group2] of complementaryPairs) {
+    const hasGroup1 = user1.tags?.some(t => 
+      group1.some(g => t.toLowerCase().includes(g))
+    );
+    const hasGroup2 = user2.tags?.some(t => 
+      group2.some(g => t.toLowerCase().includes(g))
+    );
+    
+    if ((hasGroup1 && hasGroup2) || (user1.tags?.some(t => group2.some(g => t.toLowerCase().includes(g))) && user2.tags?.some(t => group1.some(g => t.toLowerCase().includes(g))))) {
+      score += 18; // Higher weight for complementary skills
+      reasons.push('Complementary skills - great collaboration potential');
+      break;
+    }
+  }
+  
+  // Recent activity boost
+  const now = Date.now();
+  const oneWeekAgo = now - (7 * 24 * 60 * 60 * 1000);
+  
+  if (user1.lastSeen && user1.lastSeen > oneWeekAgo && 
+      user2.lastSeen && user2.lastSeen > oneWeekAgo) {
+    score += 8;
+    reasons.push('Both recently active');
+  }
+  
+  // Shipping activity boost
+  if (user1.ships?.length > 0 && user2.ships?.length > 0) {
+    const recentShips = user1.ships.filter(s => s.timestamp > oneWeekAgo).length +
+                       user2.ships.filter(s => s.timestamp > oneWeekAgo).length;
+    if (recentShips > 0) {
+      score += recentShips * 5;
+      reasons.push('Active builders');
+    }
+  }
+  
+  return { score, reasons: reasons.slice(0, 3) };
+}
+
+// Find the best potential matches for a user
+async function findBestMatches(targetHandle, limit = 3) {
+  const targetProfile = await userProfiles.getProfile(targetHandle);
+  const allProfiles = await userProfiles.getAllProfiles();
+  
+  const candidates = allProfiles.filter(p => 
+    p.handle !== targetHandle && 
+    p.building && 
+    (p.interests?.length > 0 || p.tags?.length > 0)
+  );
+  
+  const matches = [];
+  
+  for (const candidate of candidates) {
+    // Skip if already connected
+    const alreadyConnected = await userProfiles.hasBeenConnected(targetHandle, candidate.handle);
+    if (alreadyConnected) continue;
+    
+    const match = calculateEnhancedMatchScore(targetProfile, candidate);
+    if (match.score >= 20) { // Higher threshold for auto-suggestions
+      matches.push({
+        handle: candidate.handle,
+        score: match.score,
+        reasons: match.reasons,
+        building: candidate.building,
+        interests: candidate.interests || [],
+        tags: candidate.tags || [],
+        lastSeen: candidate.lastSeen
+      });
+    }
+  }
+  
+  return matches.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// Generate and queue connection suggestions
+async function generateSuggestions() {
+  const profiles = await userProfiles.getAllProfiles();
+  const now = Date.now();
+  const oneWeekAgo = now - (7 * 24 * 60 * 60 * 1000);
+  
+  // Focus on recently active users with complete profiles
+  const activeUsers = profiles.filter(p => 
+    p.lastSeen && p.lastSeen > oneWeekAgo &&
+    p.building && p.interests?.length > 0
+  );
+  
+  if (activeUsers.length < 2) {
+    return {
+      success: false,
+      reason: 'Not enough active users with complete profiles',
+      activeUsers: activeUsers.length
+    };
+  }
+  
+  const suggestions = [];
+  
+  for (const user of activeUsers) {
+    const matches = await findBestMatches(user.handle, 2);
+    
+    for (const match of matches) {
+      // Generate personalized introduction
+      const intro = await smartIntro.generateIntroduction(user.handle, match.handle, 'casual');
+      
+      suggestions.push({
+        from: user.handle,
+        to: match.handle,
+        score: match.score,
+        reasons: match.reasons,
+        introduction: intro,
+        timestamp: now
+      });
+    }
+  }
+  
+  return {
+    success: true,
+    suggestions: suggestions.sort((a, b) => b.score - a.score).slice(0, 8),
+    totalGenerated: suggestions.length
+  };
+}
+
+// Intelligent timing for connection suggestions
+function getOptimalSuggestionTime() {
+  const now = new Date();
+  const currentHour = now.getHours();
+  const currentDay = now.getDay();
+  
+  // Best times based on typical developer/builder activity:
+  // Weekdays: 9-11am, 2-4pm, 7-9pm
+  // Weekends: 10am-12pm, 2-5pm
+  
+  const isWeekend = currentDay === 0 || currentDay === 6;
+  const goodTimes = isWeekend 
+    ? [10, 11, 14, 15, 16, 17] 
+    : [9, 10, 14, 15, 19, 20];
+  
+  const isOptimalTime = goodTimes.includes(currentHour);
+  
+  return {
+    isOptimal: isOptimalTime,
+    currentHour,
+    recommendation: isOptimalTime 
+      ? 'Good time for connection suggestions'
+      : `Better to suggest connections at ${goodTimes.join(', ')} o'clock`
+  };
+}
+
+// Track suggestion success (when users actually connect)
+async function trackSuggestionSuccess(fromHandle, toHandle, successful) {
+  // This would integrate with actual connection tracking
+  // For now, we'll update connection records
+  
+  if (successful) {
+    await userProfiles.recordConnection(
+      fromHandle, 
+      toHandle, 
+      'Auto-suggested connection - successful match'
+    );
+  }
+  
+  return { tracked: true, successful };
+}
+
+// Main auto-suggestion workflow
+async function runAutoSuggestions() {
+  const startTime = Date.now();
+  
+  // Check if it's a good time for suggestions
+  const timing = getOptimalSuggestionTime();
+  
+  // Generate suggestions
+  const result = await generateSuggestions();
+  
+  if (!result.success) {
+    return {
+      success: false,
+      message: result.reason,
+      timing: timing.recommendation,
+      duration: Date.now() - startTime
+    };
+  }
+  
+  const summary = {
+    success: true,
+    suggestionsGenerated: result.suggestions.length,
+    highQualityMatches: result.suggestions.filter(s => s.score >= 35).length,
+    topSuggestion: result.suggestions[0] || null,
+    timing: timing.isOptimal ? 'optimal' : 'suboptimal',
+    duration: Date.now() - startTime
+  };
+  
+  // If it's optimal timing, we could actually send the suggestions
+  if (timing.isOptimal && result.suggestions.length > 0) {
+    summary.recommendedAction = 'Send top 3 suggestions to users';
+    summary.topSuggestions = result.suggestions.slice(0, 3).map(s => ({
+      connection: `@${s.from} → @${s.to}`,
+      score: s.score,
+      primaryReason: s.reasons[0] || 'Good match'
+    }));
+  }
+  
+  return summary;
+}
+
+module.exports = {
+  calculateEnhancedMatchScore,
+  findBestMatches,
+  generateSuggestions,
+  getOptimalSuggestionTime,
+  trackSuggestionSuccess,
+  runAutoSuggestions
+};