slashvibe-mcp 0.3.21 → 0.3.23

package/tools/_discovery.js

@@ -12,33 +12,33 @@
 const INTEREST_CLUSTERS = {
   'ai-ml': ['ai', 'machine learning', 'deep learning', 'neural networks', 'llm', 'gpt', 'artificial intelligence'],
   'web-dev': ['frontend', 'backend', 'fullstack', 'web development', 'javascript', 'react', 'vue', 'angular'],
-  'mobile': ['ios', 'android', 'react native', 'flutter', 'mobile development', 'swift', 'kotlin'],
-  'startups': ['entrepreneur', 'startup', 'founder', 'business', 'venture capital', 'product market fit'],
-  'design': ['ui design', 'ux design', 'product design', 'graphic design', 'figma', 'sketch'],
-  'blockchain': ['blockchain', 'crypto', 'web3', 'defi', 'nft', 'ethereum', 'bitcoin'],
-  'data': ['data science', 'analytics', 'big data', 'data engineering', 'sql', 'python'],
-  'gaming': ['game development', 'unity', 'unreal', 'indie games', 'gaming'],
-  'devops': ['devops', 'kubernetes', 'docker', 'aws', 'cloud', 'infrastructure'],
-  'content': ['writing', 'blogging', 'content creation', 'marketing', 'social media']
+  mobile: ['ios', 'android', 'react native', 'flutter', 'mobile development', 'swift', 'kotlin'],
+  startups: ['entrepreneur', 'startup', 'founder', 'business', 'venture capital', 'product market fit'],
+  design: ['ui design', 'ux design', 'product design', 'graphic design', 'figma', 'sketch'],
+  blockchain: ['blockchain', 'crypto', 'web3', 'defi', 'nft', 'ethereum', 'bitcoin'],
+  data: ['data science', 'analytics', 'big data', 'data engineering', 'sql', 'python'],
+  gaming: ['game development', 'unity', 'unreal', 'indie games', 'gaming'],
+  devops: ['devops', 'kubernetes', 'docker', 'aws', 'cloud', 'infrastructure'],
+  content: ['writing', 'blogging', 'content creation', 'marketing', 'social media']
 };
 
 // Technology skill clusters for complementary matching
 const SKILL_CLUSTERS = {
-  'frontend': ['react', 'vue', 'angular', 'typescript', 'javascript', 'css', 'html'],
-  'backend': ['node.js', 'python', 'java', 'go', 'rust', 'express', 'django'],
-  'mobile': ['swift', 'kotlin', 'react-native', 'flutter', 'ionic'],
-  'data': ['python', 'r', 'sql', 'pandas', 'tensorflow', 'pytorch'],
-  'devops': ['docker', 'kubernetes', 'aws', 'azure', 'terraform', 'jenkins'],
-  'design': ['figma', 'sketch', 'photoshop', 'illustrator', 'principle']
+  frontend: ['react', 'vue', 'angular', 'typescript', 'javascript', 'css', 'html'],
+  backend: ['node.js', 'python', 'java', 'go', 'rust', 'express', 'django'],
+  mobile: ['swift', 'kotlin', 'react-native', 'flutter', 'ionic'],
+  data: ['python', 'r', 'sql', 'pandas', 'tensorflow', 'pytorch'],
+  devops: ['docker', 'kubernetes', 'aws', 'azure', 'terraform', 'jenkins'],
+  design: ['figma', 'sketch', 'photoshop', 'illustrator', 'principle']
 };
 
 // Calculate semantic similarity between interests
 function calculateInterestSimilarity(interests1, interests2) {
   if (!interests1?.length || !interests2?.length) return 0;
-  
+
   let score = 0;
   const matches = [];
-  
+
   // Direct matches (highest weight)
   for (const interest1 of interests1) {
     for (const interest2 of interests2) {
@@ -48,45 +48,41 @@ function calculateInterestSimilarity(interests1, interests2) {
       }
     }
   }
-  
+
   // Cluster-based similarity (medium weight)
   for (const [clusterName, keywords] of Object.entries(INTEREST_CLUSTERS)) {
-    const user1InCluster = interests1.some(i => 
-      keywords.some(k => i.toLowerCase().includes(k.toLowerCase()))
-    );
-    const user2InCluster = interests2.some(i => 
-      keywords.some(k => i.toLowerCase().includes(k.toLowerCase()))
-    );
-    
+    const user1InCluster = interests1.some(i => keywords.some(k => i.toLowerCase().includes(k.toLowerCase())));
+    const user2InCluster = interests2.some(i => keywords.some(k => i.toLowerCase().includes(k.toLowerCase())));
+
     if (user1InCluster && user2InCluster) {
       score += 12;
       matches.push(clusterName);
     }
   }
-  
+
   // Keyword similarity (lower weight)
   for (const interest1 of interests1) {
     for (const interest2 of interests2) {
       const words1 = interest1.toLowerCase().split(/\s+/);
       const words2 = interest2.toLowerCase().split(/\s+/);
       const commonWords = words1.filter(w => words2.includes(w) && w.length > 3);
-      
+
       if (commonWords.length > 0) {
         score += commonWords.length * 3;
       }
     }
   }
-  
+
   return { score, matches: [...new Set(matches)].slice(0, 3) };
 }
 
 // Calculate tag/skill complementarity
 function calculateSkillComplementarity(tags1, tags2) {
   if (!tags1?.length || !tags2?.length) return { score: 0, pairs: [] };
-  
+
   let score = 0;
   const pairs = [];
-  
+
   // Find complementary pairs
   const complementaryPairs = [
     ['frontend', 'backend'],
@@ -97,27 +93,20 @@ function calculateSkillComplementarity(tags1, tags2) {
     ['devops', 'backend'],
     ['marketing', 'product']
   ];
-  
+
   for (const [skill1, skill2] of complementaryPairs) {
     const user1HasSkill1 = tags1.some(t => t.toLowerCase().includes(skill1.toLowerCase()));
     const user1HasSkill2 = tags1.some(t => t.toLowerCase().includes(skill2.toLowerCase()));
     const user2HasSkill1 = tags2.some(t => t.toLowerCase().includes(skill1.toLowerCase()));
     const user2HasSkill2 = tags2.some(t => t.toLowerCase().includes(skill2.toLowerCase()));
-    
+
     if ((user1HasSkill1 && user2HasSkill2) || (user1HasSkill2 && user2HasSkill1)) {
       score += 15;
       pairs.push(`${skill1}/${skill2}`);
     }
   }
-  
-  return { score, pairs: pairs.slice(0, 2) };
-}
 
-// Helper: Check for word boundary match (avoids "said" matching "ai", "start" matching "art")
-function hasWord(text, word) {
-  // Use word boundary regex for short keywords prone to false positives
-  const regex = new RegExp(`\\b${word}\\b`, 'i');
-  return regex.test(text);
+  return { score, pairs: pairs.slice(0, 2) };
 }
 
 // Suggest interests based on what user is building
@@ -127,169 +116,83 @@ function suggestInterestsFromBuilding(buildingDescription) {
   const building = buildingDescription.toLowerCase();
   const suggestions = [];
 
-  // Agent/Automation projects (critical for /vibe users!)
-  if (building.includes('agent') || building.includes('automation') ||
-      hasWord(building, 'mcp') || building.includes('claude') ||
-      building.includes('orchestrat') || building.includes('workflow')) {
-    suggestions.push('agents', 'ai', 'automation');
-  }
-
-  // AI/ML projects (use word boundary for short keywords)
-  if (hasWord(building, 'ai') || building.includes('machine learning') ||
-      hasWord(building, 'llm') || hasWord(building, 'gpt') ||
-      building.includes('neural') || hasWord(building, 'ml')) {
-    suggestions.push('ai', 'machine learning');
+  // AI/ML projects
+  if (building.includes('ai') || building.includes('machine learning') || building.includes('llm')) {
+    suggestions.push('ai', 'machine learning', 'deep learning');
   }
 
   // Web projects
-  if (building.includes('web') || building.includes('website') ||
-      building.includes('frontend') || building.includes('react') ||
-      building.includes('next') || building.includes('vue')) {
-    suggestions.push('web development', 'frontend');
-  }
-
-  // Backend/API projects
-  if (building.includes('api') || building.includes('backend') ||
-      building.includes('server') || building.includes('database')) {
-    suggestions.push('backend', 'api');
+  if (building.includes('web') || building.includes('website') || building.includes('app')) {
+    suggestions.push('web development', 'frontend', 'fullstack');
   }
 
   // Mobile projects
-  if (building.includes('mobile') || building.includes('ios') ||
-      building.includes('android') || building.includes('flutter') ||
-      building.includes('react native')) {
-    suggestions.push('mobile development');
-  }
-
-  // Platform/SaaS projects (NEW)
-  if (building.includes('platform') || building.includes('saas') ||
-      building.includes('.app') || building.includes('product')) {
-    suggestions.push('platform', 'saas', 'product');
+  if (building.includes('mobile') || building.includes('ios') || building.includes('android')) {
+    suggestions.push('mobile development', 'app development');
   }
 
   // Startup/business projects
-  if (building.includes('startup') || building.includes('business') ||
-      building.includes('founder') || building.includes('company')) {
-    suggestions.push('startups', 'entrepreneur');
+  if (building.includes('startup') || building.includes('business') || building.includes('saas')) {
+    suggestions.push('startups', 'entrepreneur', 'product management');
   }
 
   // Data projects
-  if (building.includes('data') || building.includes('analytics') ||
-      building.includes('dashboard') || building.includes('visualization')) {
-    suggestions.push('data science', 'analytics');
-  }
-
-  // Developer tools (NEW)
-  if (building.includes('tool') || building.includes('cli') ||
-      building.includes('developer') || building.includes('devtool') ||
-      building.includes('editor') || building.includes('ide')) {
-    suggestions.push('developer tools', 'infrastructure');
-  }
-
-  // Creative/Generative projects (NEW)
-  if (hasWord(building, 'art') || building.includes('generative') ||
-      building.includes('creative') || building.includes('music') ||
-      building.includes('visual') || building.includes('design')) {
-    suggestions.push('generative art', 'creative');
+  if (building.includes('data') || building.includes('analytics') || building.includes('dashboard')) {
+    suggestions.push('data science', 'analytics', 'visualization');
   }
 
   // Content/media projects
-  if (building.includes('content') || building.includes('blog') ||
-      building.includes('media') || building.includes('writing')) {
-    suggestions.push('content creation', 'writing');
+  if (building.includes('content') || building.includes('blog') || building.includes('media')) {
+    suggestions.push('content creation', 'writing', 'marketing');
   }
 
   // Gaming projects
-  if (building.includes('game') || building.includes('unity') ||
-      building.includes('gaming') || building.includes('interactive')) {
-    suggestions.push('game development', 'gaming');
-  }
-
-  // Infrastructure/DevOps (NEW)
-  if (building.includes('infrastructure') || building.includes('devops') ||
-      building.includes('cloud') || building.includes('deploy') ||
-      building.includes('kubernetes') || building.includes('docker')) {
-    suggestions.push('devops', 'infrastructure');
-  }
-
-  // Social/Community (NEW)
-  if (building.includes('social') || building.includes('community') ||
-      building.includes('network') || building.includes('chat') ||
-      building.includes('messaging')) {
-    suggestions.push('social', 'community');
-  }
-
-  // Crypto/Web3 (NEW)
-  if (building.includes('crypto') || building.includes('web3') ||
-      building.includes('blockchain') || building.includes('defi') ||
-      building.includes('nft') || building.includes('token')) {
-    suggestions.push('crypto', 'web3');
-  }
-
-  // Education (NEW)
-  if (building.includes('education') || building.includes('learning') ||
-      building.includes('course') || building.includes('tutorial') ||
-      building.includes('teaching')) {
-    suggestions.push('education', 'learning');
+  if (building.includes('game') || building.includes('unity') || building.includes('gaming')) {
+    suggestions.push('game development', 'gaming', 'interactive media');
   }
 
-  // Fintech (NEW)
-  if (building.includes('fintech') || building.includes('payment') ||
-      building.includes('banking') || building.includes('finance') ||
-      building.includes('trading')) {
-    suggestions.push('fintech', 'finance');
-  }
-
-  // Health/Biotech (NEW)
-  if (building.includes('health') || building.includes('biotech') ||
-      building.includes('medical') || building.includes('fitness') ||
-      building.includes('wellness')) {
-    suggestions.push('healthtech', 'biotech');
-  }
-
-  // Return unique interests, limited to 5
-  return [...new Set(suggestions)].slice(0, 5);
+  return [...new Set(suggestions)].slice(0, 4);
 }
 
 // Suggest tags/skills based on interests and building
 function suggestTagsFromProfile(interests, building) {
   const suggestions = [];
-  
+
   // From interests
   if (interests) {
     for (const interest of interests) {
       const interestLower = interest.toLowerCase();
-      
+
       if (interestLower.includes('ai') || interestLower.includes('machine learning')) {
         suggestions.push('python', 'tensorflow', 'pytorch', 'data-science');
       }
-      
+
       if (interestLower.includes('web') || interestLower.includes('frontend')) {
         suggestions.push('react', 'javascript', 'typescript', 'css');
       }
-      
+
       if (interestLower.includes('mobile')) {
         suggestions.push('swift', 'kotlin', 'react-native', 'flutter');
       }
-      
+
       if (interestLower.includes('data')) {
         suggestions.push('python', 'sql', 'pandas', 'analytics');
       }
-      
+
       if (interestLower.includes('design')) {
         suggestions.push('figma', 'ui-design', 'ux-design', 'prototyping');
       }
-      
+
       if (interestLower.includes('startup') || interestLower.includes('business')) {
         suggestions.push('product-management', 'strategy', 'growth', 'founder');
       }
     }
   }
-  
+
   // From building description
   if (building) {
     const buildingLower = building.toLowerCase();
-    
+
     if (buildingLower.includes('react')) suggestions.push('react', 'frontend', 'javascript');
     if (buildingLower.includes('python')) suggestions.push('python', 'backend', 'data-science');
     if (buildingLower.includes('node')) suggestions.push('nodejs', 'backend', 'javascript');
@@ -297,7 +200,7 @@ function suggestTagsFromProfile(interests, building) {
       suggestions.push('ai', 'machine-learning', 'python');
     }
   }
-  
+
   return [...new Set(suggestions)].slice(0, 6);
 }
 
@@ -305,49 +208,53 @@ function suggestTagsFromProfile(interests, building) {
 function calculateAdvancedMatchScore(user1, user2) {
   let totalScore = 0;
   const reasons = [];
-  
+
   // Interest similarity (high weight)
   const interestSim = calculateInterestSimilarity(user1.interests, user2.interests);
   totalScore += interestSim.score;
   if (interestSim.matches.length > 0) {
     reasons.push(`Shared interests: ${interestSim.matches.join(', ')}`);
   }
-  
+
   // Tag overlap (medium-high weight)
   if (user1.tags && user2.tags) {
-    const sharedTags = user1.tags.filter(t => 
-      user2.tags.some(t2 => t2.toLowerCase() === t.toLowerCase())
-    );
+    const sharedTags = user1.tags.filter(t => user2.tags.some(t2 => t2.toLowerCase() === t.toLowerCase()));
     if (sharedTags.length > 0) {
       totalScore += sharedTags.length * 12;
       reasons.push(`Common skills: ${sharedTags.join(', ')}`);
     }
   }
-  
+
   // Skill complementarity (medium weight)
   const skillComp = calculateSkillComplementarity(user1.tags, user2.tags);
   totalScore += skillComp.score;
   if (skillComp.pairs.length > 0) {
     reasons.push(`Complementary skills: ${skillComp.pairs.join(', ')}`);
   }
-  
+
   // Building similarity (medium weight)
   if (user1.building && user2.building) {
-    const building1Words = user1.building.toLowerCase().split(/\s+/).filter(w => w.length > 3);
-    const building2Words = user2.building.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+    const building1Words = user1.building
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(w => w.length > 3);
+    const building2Words = user2.building
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(w => w.length > 3);
     const commonBuildingWords = building1Words.filter(w => building2Words.includes(w));
-    
+
     if (commonBuildingWords.length > 0) {
       totalScore += commonBuildingWords.length * 8;
       reasons.push(`Both building ${commonBuildingWords.join(', ')} projects`);
     }
   }
-  
+
   // Activity timing (low weight but important for connection success)
   if (user1.lastSeen && user2.lastSeen) {
     const timeDiff = Math.abs(user1.lastSeen - user2.lastSeen);
     const hours = timeDiff / (1000 * 60 * 60);
-    
+
     if (hours < 2) {
       totalScore += 15;
       reasons.push('Both active recently');
@@ -356,17 +263,15 @@ function calculateAdvancedMatchScore(user1, user2) {
       reasons.push('Similar activity patterns');
     }
   }
-  
+
   // Connection history penalty (avoid repeat suggestions)
   if (user1.connections && user2.connections) {
-    const alreadyConnected = user1.connections.some(c => 
-      c.handle === user2.handle.toLowerCase()
-    );
+    const alreadyConnected = user1.connections.some(c => c.handle === user2.handle.toLowerCase());
     if (alreadyConnected) {
       totalScore -= 50; // Heavy penalty
     }
   }
-  
+
   return {
     score: Math.max(0, totalScore),
     reasons: reasons.slice(0, 3) // Top 3 reasons
@@ -376,13 +281,14 @@ function calculateAdvancedMatchScore(user1, user2) {
 // Find the best matches for a user from a pool of candidates
 function findBestMatches(targetUser, candidates, limit = 5) {
   const matches = [];
-  
+
   for (const candidate of candidates) {
     if (candidate.handle === targetUser.handle) continue;
-    
+
     const match = calculateAdvancedMatchScore(targetUser, candidate);
-    
-    if (match.score > 10) { // Minimum threshold
+
+    if (match.score > 10) {
+      // Minimum threshold
       matches.push({
         ...candidate,
         matchScore: match.score,
@@ -390,36 +296,32 @@ function findBestMatches(targetUser, candidates, limit = 5) {
       });
     }
   }
-  
-  return matches
-    .sort((a, b) => b.matchScore - a.matchScore)
-    .slice(0, limit);
+
+  return matches.sort((a, b) => b.matchScore - a.matchScore).slice(0, limit);
 }
 
 // Group users by interest clusters
 function groupUsersByInterestClusters(users) {
   const clusters = {};
-  
+
   for (const user of users) {
     if (!user.interests?.length) continue;
-    
+
     for (const [clusterName, keywords] of Object.entries(INTEREST_CLUSTERS)) {
       const matchesCluster = user.interests.some(interest =>
-        keywords.some(keyword => 
-          interest.toLowerCase().includes(keyword.toLowerCase())
-        )
+        keywords.some(keyword => interest.toLowerCase().includes(keyword.toLowerCase()))
       );
-      
+
       if (matchesCluster) {
         if (!clusters[clusterName]) clusters[clusterName] = [];
         clusters[clusterName].push(user);
       }
     }
   }
-  
+
   // Sort clusters by size
   return Object.entries(clusters)
-    .sort(([,a], [,b]) => b.length - a.length)
+    .sort(([, a], [, b]) => b.length - a.length)
     .reduce((acc, [key, value]) => {
       acc[key] = value;
       return acc;
@@ -436,4 +338,4 @@ module.exports = {
   groupUsersByInterestClusters,
   INTEREST_CLUSTERS,
   SKILL_CLUSTERS
-};
+};