slashvibe-mcp 0.3.21 → 0.3.23

package/tools/_deprecated/discovery-insights.js

@@ -1,384 +0,0 @@
-/**
- * vibe discovery-insights — Discovery System Analytics
- *
- * Provides insights into connection patterns, popular skills,
- * and optimization recommendations for better matching.
- *
- * Commands:
- * - discovery-insights stats — Show discovery system statistics
- * - discovery-insights skills — Most popular/requested skills
- * - discovery-insights gaps — Identify skill gaps in community
- * - discovery-insights trends — Recent activity trends
- */
-
-const config = require('../config');
-const store = require('../store');
-const userProfiles = require('../store/profiles');
-const { formatTimeAgo, requireInit } = require('./_shared');
-
-const definition = {
-  name: 'vibe_discovery_insights',
-  description: 'Analytics and insights for the discovery system to optimize matching.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      command: {
-        type: 'string',
-        enum: ['stats', 'skills', 'gaps', 'trends'],
-        description: 'Discovery insights command to run'
-      }
-    }
-  }
-};
-
-// Analyze community profiles
-async function analyzeProfiles() {
-  const allProfiles = await userProfiles.getAllProfiles();
-  
-  const stats = {
-    totalUsers: allProfiles.length,
-    withBuilding: 0,
-    withTags: 0,
-    withInterests: 0,
-    avgSkillsPerUser: 0,
-    avgInterestsPerUser: 0,
-    completionRate: 0
-  };
-  
-  let totalSkills = 0;
-  let totalInterests = 0;
-  
-  for (const profile of allProfiles) {
-    if (profile.building) stats.withBuilding++;
-    if (profile.tags && profile.tags.length > 0) {
-      stats.withTags++;
-      totalSkills += profile.tags.length;
-    }
-    if (profile.interests && profile.interests.length > 0) {
-      stats.withInterests++;
-      totalInterests += profile.interests.length;
-    }
-  }
-  
-  stats.avgSkillsPerUser = Math.round((totalSkills / Math.max(stats.withTags, 1)) * 10) / 10;
-  stats.avgInterestsPerUser = Math.round((totalInterests / Math.max(stats.withInterests, 1)) * 10) / 10;
-  stats.completionRate = Math.round((stats.withBuilding + stats.withTags + stats.withInterests) / (stats.totalUsers * 3) * 100);
-  
-  return stats;
-}
-
-// Analyze skill distribution
-async function analyzeSkills() {
-  const allProfiles = await userProfiles.getAllProfiles();
-  const skillExchanges = await store.getSkillExchanges() || [];
-  
-  const skillCounts = {};
-  const requestedSkills = {};
-  const offeredSkills = {};
-  
-  // Count skills from profiles
-  for (const profile of allProfiles) {
-    if (profile.tags) {
-      for (const skill of profile.tags) {
-        skillCounts[skill] = (skillCounts[skill] || 0) + 1;
-      }
-    }
-  }
-  
-  // Count skills from exchanges
-  for (const exchange of skillExchanges) {
-    if (exchange.type === 'offer') {
-      offeredSkills[exchange.skill] = (offeredSkills[exchange.skill] || 0) + 1;
-    } else if (exchange.type === 'request') {
-      requestedSkills[exchange.skill] = (requestedSkills[exchange.skill] || 0) + 1;
-    }
-  }
-  
-  // Sort by popularity
-  const popularSkills = Object.entries(skillCounts)
-    .sort(([,a], [,b]) => b - a)
-    .slice(0, 10);
-    
-  const topRequested = Object.entries(requestedSkills)
-    .sort(([,a], [,b]) => b - a)
-    .slice(0, 5);
-    
-  const topOffered = Object.entries(offeredSkills)
-    .sort(([,a], [,b]) => b - a)
-    .slice(0, 5);
-  
-  return {
-    popular: popularSkills,
-    requested: topRequested,
-    offered: topOffered,
-    totalSkills: Object.keys(skillCounts).length
-  };
-}
-
-// Identify skill gaps (high demand, low supply)
-async function identifySkillGaps() {
-  const skillExchanges = await store.getSkillExchanges() || [];
-  const allProfiles = await userProfiles.getAllProfiles();
-  
-  const requests = {};
-  const offers = {};
-  const profileSkills = {};
-  
-  // Count requests and offers
-  for (const exchange of skillExchanges) {
-    if (exchange.type === 'request') {
-      requests[exchange.skill] = (requests[exchange.skill] || 0) + 1;
-    } else if (exchange.type === 'offer') {
-      offers[exchange.skill] = (offers[exchange.skill] || 0) + 1;
-    }
-  }
-  
-  // Count skills in profiles
-  for (const profile of allProfiles) {
-    if (profile.tags) {
-      for (const skill of profile.tags) {
-        profileSkills[skill] = (profileSkills[skill] || 0) + 1;
-      }
-    }
-  }
-  
-  // Find gaps (requested but not available)
-  const gaps = [];
-  for (const [skill, requestCount] of Object.entries(requests)) {
-    const offerCount = offers[skill] || 0;
-    const profileCount = profileSkills[skill] || 0;
-    const totalSupply = offerCount + profileCount;
-    
-    if (requestCount > totalSupply) {
-      gaps.push({
-        skill,
-        demand: requestCount,
-        supply: totalSupply,
-        gap: requestCount - totalSupply
-      });
-    }
-  }
-  
-  return gaps.sort((a, b) => b.gap - a.gap);
-}
-
-// Analyze recent trends
-async function analyzeTrends() {
-  const skillExchanges = await store.getSkillExchanges() || [];
-  const allProfiles = await userProfiles.getAllProfiles();
-  
-  const now = Date.now();
-  const day = 24 * 60 * 60 * 1000;
-  const week = 7 * day;
-  
-  // Recent skill exchange activity
-  const recentExchanges = skillExchanges.filter(e => (now - e.timestamp) < week);
-  const todayExchanges = skillExchanges.filter(e => (now - e.timestamp) < day);
-  
-  // Active users (updated recently)
-  const activeUsers = allProfiles.filter(p => p.lastSeen && (now - p.lastSeen) < day);
-  
-  // Trending skills (most mentioned recently)
-  const recentSkills = {};
-  for (const exchange of recentExchanges) {
-    recentSkills[exchange.skill] = (recentSkills[exchange.skill] || 0) + 1;
-  }
-  
-  const trending = Object.entries(recentSkills)
-    .sort(([,a], [,b]) => b - a)
-    .slice(0, 5);
-  
-  return {
-    recentExchanges: recentExchanges.length,
-    todayExchanges: todayExchanges.length,
-    activeUsers: activeUsers.length,
-    trending,
-    weeklyGrowth: Math.round((recentExchanges.length / Math.max(skillExchanges.length - recentExchanges.length, 1)) * 100)
-  };
-}
-
-async function handler(args) {
-  const initCheck = requireInit();
-  if (initCheck) return initCheck;
-
-  const command = args.command || 'stats';
-
-  let display = '';
-
-  try {
-    switch (command) {
-      case 'stats': {
-        const stats = await analyzeProfiles();
-        
-        display = `## Discovery System Statistics 📊\n\n`;
-        
-        display += `### Community Profile Health\n`;
-        display += `**Total Users:** ${stats.totalUsers}\n`;
-        display += `**Profile Completion:** ${stats.completionRate}%\n\n`;
-        
-        display += `**Profile Elements:**\n`;
-        display += `• Building something: ${stats.withBuilding} users\n`;
-        display += `• Have skill tags: ${stats.withTags} users\n`;
-        display += `• Listed interests: ${stats.withInterests} users\n\n`;
-        
-        display += `**Depth Metrics:**\n`;
-        display += `• Avg skills per user: ${stats.avgSkillsPerUser}\n`;
-        display += `• Avg interests per user: ${stats.avgInterestsPerUser}\n\n`;
-        
-        // Recommendations
-        display += `### Optimization Recommendations\n`;
-        if (stats.completionRate < 60) {
-          display += `🎯 **Focus:** Encourage profile completion (${100 - stats.completionRate}% missing data)\n`;
-        }
-        if (stats.withTags < stats.totalUsers * 0.5) {
-          display += `🏷️ **Priority:** More users need skill tags for better matching\n`;
-        }
-        if (stats.withBuilding < stats.totalUsers * 0.7) {
-          display += `🔨 **Opportunity:** Encourage users to share what they're building\n`;
-        }
-        
-        display += `\n**Commands:**\n`;
-        display += `• \`discovery-insights skills\` — Popular skills analysis\n`;
-        display += `• \`discovery-insights gaps\` — Identify skill shortages\n`;
-        display += `• \`discovery-insights trends\` — Recent activity patterns`;
-        break;
-      }
-
-      case 'skills': {
-        const analysis = await analyzeSkills();
-        
-        display = `## Skills Analysis 🛠️\n\n`;
-        
-        if (analysis.popular.length > 0) {
-          display += `### Most Popular Skills in Community\n`;
-          for (const [skill, count] of analysis.popular) {
-            const bar = '▓'.repeat(Math.min(Math.round(count / analysis.popular[0][1] * 10), 10));
-            display += `**${skill}** (${count}) ${bar}\n`;
-          }
-          display += `\n`;
-        }
-        
-        if (analysis.requested.length > 0) {
-          display += `### Most Requested Skills\n`;
-          for (const [skill, count] of analysis.requested) {
-            display += `• **${skill}** — ${count} requests\n`;
-          }
-          display += `\n`;
-        }
-        
-        if (analysis.offered.length > 0) {
-          display += `### Most Offered Skills\n`;
-          for (const [skill, count] of analysis.offered) {
-            display += `• **${skill}** — ${count} offers\n`;
-          }
-          display += `\n`;
-        }
-        
-        display += `**Total unique skills:** ${analysis.totalSkills}\n\n`;
-        
-        display += `**Skills marketplace health:**\n`;
-        if (analysis.requested.length === 0 && analysis.offered.length === 0) {
-          display += `📋 Skills exchange is empty - encourage first posts!\n`;
-        } else {
-          display += `✅ Active skills marketplace with ${analysis.requested.length} requests, ${analysis.offered.length} offers\n`;
-        }
-        break;
-      }
-
-      case 'gaps': {
-        const gaps = await identifySkillGaps();
-        
-        display = `## Skill Gap Analysis 📈\n\n`;
-        
-        if (gaps.length === 0) {
-          display += `✅ **No skill gaps detected!**\n\n`;
-          display += `The community has good skill coverage. All requested skills have available providers.\n\n`;
-          display += `**Growth opportunities:**\n`;
-          display += `• Encourage more skill exchanges\n`;
-          display += `• Promote underutilized skills\n`;
-          display += `• Expand into new skill domains`;
-        } else {
-          display += `_Skills with high demand but limited supply:_\n\n`;
-          
-          for (const gap of gaps.slice(0, 8)) {
-            display += `**${gap.skill}**\n`;
-            display += `Demand: ${gap.demand} requests | Supply: ${gap.supply} providers\n`;
-            display += `Gap: **${gap.gap} unmet requests**\n\n`;
-          }
-          
-          display += `### Recommendations\n`;
-          display += `**Recruit for high-demand skills:**\n`;
-          for (const gap of gaps.slice(0, 3)) {
-            display += `• Find ${gap.skill} experts to join the community\n`;
-          }
-          
-          display += `\n**Encourage existing users:**\n`;
-          display += `• Share these gaps in community updates\n`;
-          display += `• Ask if anyone has hidden expertise in these areas`;
-        }
-        break;
-      }
-
-      case 'trends': {
-        const trends = await analyzeTrends();
-        
-        display = `## Discovery Activity Trends 📈\n\n`;
-        
-        display += `### Recent Activity (7 days)\n`;
-        display += `**Skill exchanges:** ${trends.recentExchanges}\n`;
-        display += `**Today:** ${trends.todayExchanges}\n`;
-        display += `**Active users:** ${trends.activeUsers}\n`;
-        display += `**Growth rate:** ${trends.weeklyGrowth}%\n\n`;
-        
-        if (trends.trending.length > 0) {
-          display += `### Trending Skills\n`;
-          for (const [skill, mentions] of trends.trending) {
-            display += `🔥 **${skill}** (${mentions} mentions)\n`;
-          }
-          display += `\n`;
-        }
-        
-        display += `### Community Health\n`;
-        if (trends.recentExchanges === 0) {
-          display += `📭 No recent skill exchange activity\n`;
-          display += `**Suggestions:** Encourage first exchanges, share success stories\n`;
-        } else if (trends.recentExchanges < 5) {
-          display += `🌱 Growing activity - encourage more participation\n`;
-        } else {
-          display += `🚀 Active community with healthy skill exchange\n`;
-        }
-        
-        if (trends.activeUsers < 3) {
-          display += `\n👥 Small but focused community - prioritize engagement\n`;
-        } else {
-          display += `\n✅ Good user activity - ${trends.activeUsers} active recently\n`;
-        }
-        break;
-      }
-
-      default:
-        display = `## Discovery Insights Commands
-
-**\`discovery-insights stats\`** — Overall system statistics and health
-**\`discovery-insights skills\`** — Popular and requested skills analysis  
-**\`discovery-insights gaps\`** — Identify skill shortages in community
-**\`discovery-insights trends\`** — Recent activity and growth patterns
-
-**Perfect for:**
-- Understanding community needs
-- Identifying recruitment priorities  
-- Optimizing matching algorithms
-- Planning community growth strategies`;
-    }
-  } catch (error) {
-    display = `## Discovery Insights Error
-
-${error.message}
-
-Try: \`discovery-insights\` for available commands`;
-  }
-
-  return { display };
-}
-
-module.exports = { definition, handler };

package/tools/_deprecated/discovery-momentum.js

@@ -1,281 +0,0 @@
-/**
- * Discovery Momentum — Enhanced matching based on shipping velocity and recent activity
- *
- * This tool improves connection quality by analyzing:
- * - Recent shipping activity (who's building similar things)
- * - Building momentum (active vs. stalled projects)
- * - Collaborative potential (complementary recent ships)
- * - Timing patterns (when people are most active)
- */
-
-const config = require('../config');
-const userProfiles = require('../store/profiles');
-const store = require('../store');
-const { formatTimeAgo } = require('./_shared');
-
-// Analyze shipping momentum and patterns
-function analyzeShippingMomentum(profile) {
-  const now = Date.now();
-  const oneWeekAgo = now - (7 * 24 * 60 * 60 * 1000);
-  const oneMonthAgo = now - (30 * 24 * 60 * 60 * 1000);
-  
-  const ships = profile.ships || [];
-  const recentShips = ships.filter(s => s.timestamp > oneWeekAgo);
-  const monthlyShips = ships.filter(s => s.timestamp > oneMonthAgo);
-  
-  // Calculate momentum score
-  let momentum = 0;
-  
-  if (recentShips.length > 0) {
-    momentum += recentShips.length * 20; // High weight for recent activity
-  }
-  
-  if (monthlyShips.length > 2) {
-    momentum += 15; // Consistent builder bonus
-  }
-  
-  // Analyze ship content for collaboration signals
-  const shipTexts = ships.map(s => s.what.toLowerCase()).join(' ');
-  const collaborationKeywords = [
-    'looking for', 'need help', 'seeking', 'collaboration', 'partner',
-    'feedback wanted', 'beta testers', 'contributors'
-  ];
-  
-  const hasCollaborationSignals = collaborationKeywords.some(keyword => 
-    shipTexts.includes(keyword)
-  );
-  
-  if (hasCollaborationSignals) {
-    momentum += 25; // Actively seeking collaboration
-  }
-  
-  // Project type analysis
-  const projectTypes = [];
-  const typeKeywords = {
-    'frontend': ['react', 'vue', 'ui', 'interface', 'web', 'frontend'],
-    'backend': ['api', 'server', 'database', 'backend', 'service'],
-    'mobile': ['ios', 'android', 'mobile', 'app'],
-    'ai': ['ai', 'ml', 'machine learning', 'gpt', 'llm'],
-    'devtools': ['cli', 'tool', 'script', 'automation', 'workflow'],
-    'design': ['design', 'figma', 'prototype', 'mockup', 'ui/ux']
-  };
-  
-  for (const [type, keywords] of Object.entries(typeKeywords)) {
-    if (keywords.some(keyword => shipTexts.includes(keyword))) {
-      projectTypes.push(type);
-    }
-  }
-  
-  return {
-    score: momentum,
-    recentShips: recentShips.length,
-    totalShips: ships.length,
-    seekingCollaboration: hasCollaborationSignals,
-    projectTypes,
-    lastShip: ships[0]?.timestamp || null
-  };
-}
-
-// Enhanced matching that considers shipping patterns
-function calculateMomentumMatch(user1, user2) {
-  const momentum1 = analyzeShippingMomentum(user1);
-  const momentum2 = analyzeShippingMomentum(user2);
-  
-  let score = 0;
-  const reasons = [];
-  
-  // Both users have recent shipping activity
-  if (momentum1.recentShips > 0 && momentum2.recentShips > 0) {
-    score += 30;
-    reasons.push(`Both actively shipping (${momentum1.recentShips + momentum2.recentShips} recent ships)`);
-  }
-  
-  // One seeks collaboration, other is active
-  if ((momentum1.seekingCollaboration && momentum2.recentShips > 0) ||
-      (momentum2.seekingCollaboration && momentum1.recentShips > 0)) {
-    score += 40;
-    reasons.push('One seeking collaboration, other actively building');
-  }
-  
-  // Both seeking collaboration
-  if (momentum1.seekingCollaboration && momentum2.seekingCollaboration) {
-    score += 25;
-    reasons.push('Both looking for collaboration partners');
-  }
-  
-  // Complementary project types
-  const complementaryPairs = [
-    ['frontend', 'backend'],
-    ['design', 'frontend'],
-    ['ai', 'backend'],
-    ['mobile', 'backend']
-  ];
-  
-  for (const [type1, type2] of complementaryPairs) {
-    if ((momentum1.projectTypes.includes(type1) && momentum2.projectTypes.includes(type2)) ||
-        (momentum1.projectTypes.includes(type2) && momentum2.projectTypes.includes(type1))) {
-      score += 35;
-      reasons.push(`Complementary skills: ${type1} + ${type2}`);
-      break;
-    }
-  }
-  
-  // Similar project types (potential knowledge sharing)
-  const similarTypes = momentum1.projectTypes.filter(type => 
-    momentum2.projectTypes.includes(type)
-  );
-  if (similarTypes.length > 0) {
-    score += 20;
-    reasons.push(`Similar focus: ${similarTypes.join(', ')}`);
-  }
-  
-  // Both consistent builders
-  if (momentum1.totalShips > 3 && momentum2.totalShips > 3) {
-    score += 15;
-    reasons.push('Both experienced builders');
-  }
-  
-  // Activity timing alignment
-  const now = Date.now();
-  const bothRecentlyActive = 
-    momentum1.lastShip && momentum1.lastShip > (now - 7 * 24 * 60 * 60 * 1000) &&
-    momentum2.lastShip && momentum2.lastShip > (now - 7 * 24 * 60 * 60 * 1000);
-  
-  if (bothRecentlyActive) {
-    score += 20;
-    reasons.push('Both shipped recently - great timing to connect');
-  }
-  
-  // Calculate confidence based on data quality
-  const dataQuality1 = (user1.building ? 1 : 0) + (user1.interests?.length || 0) + (user1.tags?.length || 0);
-  const dataQuality2 = (user2.building ? 1 : 0) + (user2.interests?.length || 0) + (user2.tags?.length || 0);
-  const confidence = Math.min(1.0, (dataQuality1 + dataQuality2) / 8);
-  
-  return {
-    score: Math.round(score * confidence),
-    reasons: reasons.slice(0, 3),
-    confidence,
-    momentum1,
-    momentum2
-  };
-}
-
-// Find momentum-based matches for a user
-async function findMomentumMatches(targetHandle, limit = 5) {
-  const targetProfile = await userProfiles.getProfile(targetHandle);
-  const allProfiles = await userProfiles.getAllProfiles();
-  
-  const candidates = allProfiles.filter(p => 
-    p.handle !== targetHandle && 
-    p.ships && p.ships.length > 0 // Must have shipping history
-  );
-  
-  const matches = [];
-  
-  for (const candidate of candidates) {
-    // Skip if already connected recently
-    const alreadyConnected = await userProfiles.hasBeenConnected(targetHandle, candidate.handle);
-    if (alreadyConnected) continue;
-    
-    const match = calculateMomentumMatch(targetProfile, candidate);
-    
-    if (match.score >= 25) { // Quality threshold
-      matches.push({
-        handle: candidate.handle,
-        score: match.score,
-        confidence: match.confidence,
-        reasons: match.reasons,
-        building: candidate.building,
-        momentum: match.momentum2,
-        lastShip: candidate.ships?.[0]
-      });
-    }
-  }
-  
-  return matches.sort((a, b) => b.score - a.score).slice(0, limit);
-}
-
-// Identify collaboration opportunities
-async function findCollaborationOpportunities() {
-  const profiles = await userProfiles.getAllProfiles();
-  const now = Date.now();
-  const oneWeekAgo = now - (7 * 24 * 60 * 60 * 1000);
-  
-  const seekingCollaboration = [];
-  const activeBuilders = [];
-  
-  for (const profile of profiles) {
-    if (!profile.ships || profile.ships.length === 0) continue;
-    
-    const momentum = analyzeShippingMomentum(profile);
-    
-    if (momentum.seekingCollaboration) {
-      seekingCollaboration.push({
-        ...profile,
-        momentum,
-        lastShip: profile.ships[0]
-      });
-    } else if (momentum.recentShips > 0) {
-      activeBuilders.push({
-        ...profile,
-        momentum,
-        lastShip: profile.ships[0]
-      });
-    }
-  }
-  
-  const opportunities = [];
-  
-  // Match seekers with active builders
-  for (const seeker of seekingCollaboration) {
-    for (const builder of activeBuilders) {
-      const match = calculateMomentumMatch(seeker, builder);
-      
-      if (match.score >= 30) {
-        opportunities.push({
-          seeker: seeker.handle,
-          builder: builder.handle,
-          score: match.score,
-          reasons: match.reasons,
-          seekerProject: seeker.lastShip?.what,
-          builderProject: builder.lastShip?.what
-        });
-      }
-    }
-  }
-  
-  return {
-    totalSeekers: seekingCollaboration.length,
-    totalActiveBuilders: activeBuilders.length,
-    opportunities: opportunities.sort((a, b) => b.score - a.score).slice(0, 8)
-  };
-}
-
-// Generate shipping-based recommendations
-async function generateShippingRecommendations(targetHandle) {
-  const matches = await findMomentumMatches(targetHandle);
-  const opportunities = await findCollaborationOpportunities();
-  const targetProfile = await userProfiles.getProfile(targetHandle);
-  const targetMomentum = analyzeShippingMomentum(targetProfile);
-  
-  return {
-    targetMomentum,
-    momentumMatches: matches,
-    collaborationOpportunities: opportunities.opportunities.filter(
-      opp => opp.seeker === targetHandle || opp.builder === targetHandle
-    ),
-    recommendations: {
-      connect: matches.slice(0, 3),
-      collaborate: opportunities.opportunities.slice(0, 2),
-      ship: targetMomentum.score < 20 ? 'Consider shipping something to increase visibility' : null
-    }
-  };
-}
-
-module.exports = {
-  analyzeShippingMomentum,
-  calculateMomentumMatch,
-  findMomentumMatches,
-  findCollaborationOpportunities,
-  generateShippingRecommendations
-};