slashvibe-mcp 0.2.2 → 0.2.4

package/tools/work-summary.js

@@ -0,0 +1,96 @@
+/**
+ * vibe_work_summary — Standalone tool for explicit context gathering
+ *
+ * Use this when you need to:
+ * - Draft a message about what you're working on
+ * - Share your progress with someone
+ * - Get context for composing a "ship" post
+ *
+ * This tool returns structured data about:
+ * - Git state (branch, recent commits, changed files)
+ * - Project info (name, type)
+ * - Pre-formatted suggestions ready for messages/presence
+ */
+
+const { gatherWorkContext } = require('./_work-context');
+
+const definition = {
+  name: 'vibe_work_summary',
+  description: 'Get a summary of what you\'re working on (git state, project info). Use before composing messages about your work.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      detail_level: {
+        type: 'string',
+        enum: ['brief', 'detailed'],
+        description: 'brief = one-liner, detailed = include commits/files'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const { detail_level = 'brief' } = args;
+
+  // Gather all context
+  const context = gatherWorkContext();
+
+  // Build display based on detail level
+  let display = '## Work Context\n\n';
+
+  // Project info
+  display += `**Project:** ${context.project.name}`;
+  if (context.project.type !== 'unknown') {
+    display += ` (${context.project.type})`;
+  }
+  display += '\n';
+
+  // Git info
+  if (context.git) {
+    display += `**Branch:** ${context.git.branch}\n`;
+
+    if (detail_level === 'detailed') {
+      // Show recent commits
+      if (context.git.recentCommits.length > 0) {
+        display += '\n**Recent commits:**\n';
+        context.git.recentCommits.forEach(c => {
+          display += `- \`${c.hash}\` ${c.message}\n`;
+        });
+      }
+
+      // Show changed files
+      if (context.git.changedFiles.length > 0) {
+        display += '\n**Changed files:**\n';
+        context.git.changedFiles.forEach(f => {
+          display += `- ${f}\n`;
+        });
+      }
+
+      // Uncommitted changes indicator
+      if (context.git.hasUncommitted) {
+        display += '\n⚠️ _Uncommitted changes_\n';
+      }
+    }
+  } else {
+    display += '_Not in a git repository_\n';
+  }
+
+  // Suggestions
+  display += '\n---\n\n';
+  display += '**Ready to use:**\n';
+  display += `- Brief: "${context.suggestions.brief}"\n`;
+  if (detail_level === 'detailed' && context.suggestions.detailed !== context.suggestions.brief) {
+    display += `- Detailed: "${context.suggestions.detailed}"\n`;
+  }
+
+  display += '\n_Use these in messages, status updates, or ship posts._';
+
+  return {
+    display,
+    // Structured data for Claude to use programmatically
+    ...context,
+    usage_hint: 'Use suggestions.brief for messages, suggestions.detailed for updates.'
+  };
+}
+
+module.exports = { definition, handler };

package/tools/workshop-buddy.js

@@ -0,0 +1,394 @@
+/**
+ * vibe workshop-buddy — Find Your Perfect Workshop Partner
+ *
+ * Pairs users based on complementary skills and interests to form
+ * productive workshop partnerships. Unlike general discovery,
+ * this focuses on active collaboration potential.
+ *
+ * Commands:
+ * - workshop-buddy find — Find your ideal workshop partner
+ * - workshop-buddy offer <skills> — Offer skills to the community
+ * - workshop-buddy seeking <skills> — What you're looking for
+ * - workshop-buddy matches — See current skill exchange opportunities
+ */
+
+const config = require('../config');
+const store = require('../store');
+const userProfiles = require('../store/profiles');
+const { formatTimeAgo, requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_workshop_buddy',
+  description: 'Find workshop partners with complementary skills for collaboration.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      command: {
+        type: 'string',
+        enum: ['find', 'offer', 'seeking', 'matches'],
+        description: 'Workshop buddy command to run'
+      },
+      skills: {
+        type: 'string',
+        description: 'Skills you offer or seek (comma-separated)'
+      }
+    }
+  }
+};
+
+// Skill complementarity matrix
+const complementarySkills = {
+  'frontend': ['backend', 'design', 'ux'],
+  'backend': ['frontend', 'devops', 'database'],
+  'design': ['frontend', 'user-research', 'engineering'],
+  'ux': ['design', 'frontend', 'user-research'],
+  'ai': ['data', 'backend', 'research'],
+  'data': ['ai', 'backend', 'analytics'],
+  'mobile': ['backend', 'design', 'ux'],
+  'devops': ['backend', 'security', 'infrastructure'],
+  'product': ['engineering', 'design', 'marketing'],
+  'engineering': ['product', 'design', 'backend'],
+  'research': ['ai', 'data', 'implementation'],
+  'marketing': ['product', 'design', 'content'],
+  'content': ['marketing', 'design', 'writing'],
+  'security': ['devops', 'backend', 'infrastructure'],
+  'infrastructure': ['devops', 'backend', 'security'],
+  'analytics': ['data', 'product', 'research'],
+  'user-research': ['ux', 'product', 'design'],
+  'writing': ['content', 'marketing', 'editing'],
+  'business': ['product', 'marketing', 'strategy'],
+  'strategy': ['business', 'product', 'leadership']
+};
+
+// Calculate workshop collaboration potential
+function calculateBuddyScore(user1, user2) {
+  let score = 0;
+  const reasons = [];
+  const collaborationPotential = [];
+
+  const user1Skills = (user1.tags || []).concat(user1.interests || []);
+  const user2Skills = (user2.tags || []).concat(user2.interests || []);
+
+  // High-value complementary skills
+  for (const skill1 of user1Skills) {
+    const complementaries = complementarySkills[skill1.toLowerCase()] || [];
+    for (const skill2 of user2Skills) {
+      if (complementaries.includes(skill2.toLowerCase())) {
+        score += 30;
+        collaborationPotential.push(`${skill1} + ${skill2}`);
+      }
+    }
+  }
+
+  // Project collaboration potential
+  if (user1.building && user2.building) {
+    const building1 = user1.building.toLowerCase();
+    const building2 = user2.building.toLowerCase();
+    
+    // Different but related domains
+    const domains = ['ai', 'web', 'mobile', 'fintech', 'healthcare', 'gaming', 'productivity'];
+    const user1Domains = domains.filter(d => building1.includes(d));
+    const user2Domains = domains.filter(d => building2.includes(d));
+    
+    if (user1Domains.length > 0 && user2Domains.length > 0) {
+      const sharedDomains = user1Domains.filter(d => user2Domains.includes(d));
+      if (sharedDomains.length > 0) {
+        score += 25;
+        reasons.push(`Both working in ${sharedDomains.join(', ')}`);
+      }
+    }
+  }
+
+  // Experience level balance
+  const user1Level = getExperienceLevel(user1);
+  const user2Level = getExperienceLevel(user2);
+  
+  if (Math.abs(user1Level - user2Level) <= 1) {
+    score += 15;
+    reasons.push('Compatible experience levels');
+  }
+
+  // Activity synchronization
+  if (user1.lastSeen && user2.lastSeen) {
+    const timeDiff = Math.abs(user1.lastSeen - user2.lastSeen);
+    const hours = timeDiff / (1000 * 60 * 60);
+    if (hours < 6) {
+      score += 20;
+      reasons.push('Active at similar times');
+    }
+  }
+
+  // Add collaboration potential to reasons
+  if (collaborationPotential.length > 0) {
+    reasons.unshift(`Perfect skill combo: ${collaborationPotential.slice(0, 2).join(', ')}`);
+  }
+
+  return { score, reasons: reasons.slice(0, 3), collaborationPotential };
+}
+
+// Estimate experience level from profile
+function getExperienceLevel(user) {
+  const skills = (user.tags || []).length;
+  const interests = (user.interests || []).length;
+  const hasBuilding = user.building ? 1 : 0;
+  
+  return Math.min(5, skills + interests + hasBuilding);
+}
+
+// Find workshop buddies
+async function findWorkshopBuddies(myHandle) {
+  const myProfile = await userProfiles.getProfile(myHandle);
+  const allProfiles = await userProfiles.getAllProfiles();
+  
+  const candidates = allProfiles.filter(p => p.handle !== myHandle);
+  const matches = [];
+
+  for (const candidate of candidates) {
+    const match = calculateBuddyScore(myProfile, candidate);
+    if (match.score > 20) { // Higher threshold for workshop partnerships
+      matches.push({
+        handle: candidate.handle,
+        score: match.score,
+        reasons: match.reasons,
+        collaborationPotential: match.collaborationPotential,
+        building: candidate.building,
+        tags: candidate.tags || [],
+        interests: candidate.interests || [],
+        lastSeen: candidate.lastSeen,
+        experienceLevel: getExperienceLevel(candidate)
+      });
+    }
+  }
+
+  return matches.sort((a, b) => b.score - a.score).slice(0, 3);
+}
+
+// Get skill offering/seeking data
+async function getSkillExchange() {
+  // This would integrate with a persistent skills marketplace
+  // For now, analyze profiles to suggest exchanges
+  const allProfiles = await userProfiles.getAllProfiles();
+  const exchanges = [];
+
+  for (const profile of allProfiles) {
+    if (profile.tags && profile.tags.length > 0) {
+      for (const skill of profile.tags) {
+        const seeking = complementarySkills[skill.toLowerCase()] || [];
+        if (seeking.length > 0) {
+          exchanges.push({
+            handle: profile.handle,
+            offering: skill,
+            seeking: seeking,
+            building: profile.building
+          });
+        }
+      }
+    }
+  }
+
+  return exchanges.slice(0, 10);
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const myHandle = config.getHandle();
+  const command = args.command || 'find';
+
+  let display = '';
+
+  try {
+    switch (command) {
+      case 'find': {
+        const buddies = await findWorkshopBuddies(myHandle);
+        
+        if (buddies.length === 0) {
+          display = `## No Workshop Buddies Found
+
+_Need more profiles to find great partnerships._
+
+**To find your perfect workshop buddy:**
+1. \`vibe update tags "your-skills"\` (e.g., "frontend, react, typescript")
+2. \`vibe update building "your current project"\`
+3. \`vibe update interests "what excites you"\`
+
+**What makes a great workshop buddy:**
+- Complementary skills (frontend + backend)
+- Similar availability/timezone
+- Compatible experience level
+- Shared domain interest`;
+        } else {
+          display = `## Your Workshop Buddy Matches 🤝\n\n`;
+          
+          for (const buddy of buddies) {
+            display += `### **@${buddy.handle}** _(${buddy.score}% match)_\n`;
+            display += `${buddy.building || 'Available for collaboration'}\n\n`;
+            
+            display += `**Why you'd work great together:**\n`;
+            for (const reason of buddy.reasons) {
+              display += `• ${reason}\n`;
+            }
+            
+            if (buddy.collaborationPotential.length > 0) {
+              display += `\n**Skill synergy:** ${buddy.collaborationPotential.slice(0, 2).join(', ')}\n`;
+            }
+            
+            display += `**Their skills:** ${buddy.tags.join(', ')}\n`;
+            display += `**Experience level:** ${'⭐'.repeat(buddy.experienceLevel)}\n`;
+            display += `_Last seen: ${formatTimeAgo(buddy.lastSeen)}_\n\n`;
+            display += `**Reach out:** \`message @${buddy.handle} "Hey! We seem like a great workshop match..."\`\n\n`;
+            display += '---\n\n';
+          }
+          
+          display += `**Next steps:**\n`;
+          display += `• Message your top match to start collaborating\n`;
+          display += `• Use \`workshop-buddy matches\` to see community skill exchanges\n`;
+          display += `• Try \`workshop-buddy seeking "skill"\` to find specific expertise`;
+        }
+        break;
+      }
+
+      case 'offer': {
+        if (!args.skills) {
+          return { error: 'Specify skills you offer: workshop-buddy offer "frontend, react"' };
+        }
+        
+        // Update user tags with offered skills
+        const skills = args.skills.split(',').map(s => s.trim().toLowerCase());
+        const currentProfile = await userProfiles.getProfile(myHandle);
+        const updatedTags = [...new Set([...(currentProfile.tags || []), ...skills])];
+        
+        await userProfiles.updateProfile(myHandle, { tags: updatedTags });
+        
+        display = `## Skills Offered! 🎯
+
+**You're now offering:** ${skills.join(', ')}
+
+People looking for these skills can find you via:
+- \`discover search "${skills[0]}"\`
+- \`workshop-buddy matches\`
+
+**Want to find collaboration opportunities?**
+\`workshop-buddy find\` — Find your ideal workshop partner`;
+        break;
+      }
+
+      case 'seeking': {
+        if (!args.skills) {
+          return { error: 'Specify skills you need: workshop-buddy seeking "backend, devops"' };
+        }
+        
+        const seekingSkills = args.skills.split(',').map(s => s.trim().toLowerCase());
+        const allProfiles = await userProfiles.getAllProfiles();
+        
+        const matches = allProfiles.filter(profile => {
+          const theirSkills = (profile.tags || []).map(t => t.toLowerCase());
+          return seekingSkills.some(skill => theirSkills.includes(skill)) && profile.handle !== myHandle;
+        });
+        
+        if (matches.length === 0) {
+          display = `## No One Found with: ${args.skills}
+
+**Try:**
+- \`discover search "${seekingSkills[0]}"\` for broader search
+- \`workshop-buddy matches\` to browse all skill exchanges
+- Post what you're seeking: \`ship "Looking for ${args.skills} expertise"\``;
+        } else {
+          display = `## People with: ${args.skills}\n\n`;
+          
+          for (const match of matches) {
+            const theirMatchingSkills = (match.tags || []).filter(t => 
+              seekingSkills.includes(t.toLowerCase())
+            );
+            
+            display += `**@${match.handle}**\n`;
+            display += `${match.building || 'Available to help'}\n`;
+            display += `**Has:** ${theirMatchingSkills.join(', ')}\n`;
+            display += `**All skills:** ${(match.tags || []).join(', ')}\n`;
+            display += `_Last seen: ${formatTimeAgo(match.lastSeen)}_\n\n`;
+          }
+          
+          display += `**Ready to collaborate?**\n`;
+          display += `\`workshop-buddy find\` — See your best overall matches`;
+        }
+        break;
+      }
+
+      case 'matches': {
+        const exchanges = await getSkillExchange();
+        
+        if (exchanges.length === 0) {
+          display = `## No Skill Exchanges Yet
+
+_The skill marketplace is empty._
+
+**Start the exchange:**
+1. \`workshop-buddy offer "your-skills"\`
+2. Others can find you via \`workshop-buddy seeking "your-skills"\`
+
+**Example skills to offer/seek:**
+- Technical: frontend, backend, mobile, ai, data
+- Design: ui, ux, illustration, branding  
+- Business: product, marketing, strategy, writing`;
+        } else {
+          display = `## Community Skill Exchange 🔄\n\n`;
+          
+          const groupedByOffering = {};
+          for (const exchange of exchanges) {
+            if (!groupedByOffering[exchange.offering]) {
+              groupedByOffering[exchange.offering] = [];
+            }
+            groupedByOffering[exchange.offering].push(exchange);
+          }
+          
+          for (const [skill, providers] of Object.entries(groupedByOffering)) {
+            display += `### ${skill.toUpperCase()}\n`;
+            
+            for (const provider of providers.slice(0, 3)) {
+              display += `**@${provider.handle}** offers ${skill}, seeks: ${provider.seeking.join(', ')}\n`;
+              if (provider.building) {
+                display += `_Building: ${provider.building}_\n`;
+              }
+            }
+            
+            display += '\n';
+          }
+          
+          display += `**Find your perfect exchange:**\n`;
+          display += `- \`workshop-buddy seeking "skill"\` to find specific expertise\n`;
+          display += `- \`workshop-buddy find\` for AI-matched partners`;
+        }
+        break;
+      }
+
+      default:
+        display = `## Workshop Buddy Commands
+
+**\`workshop-buddy find\`** — Find your ideal workshop partner
+**\`workshop-buddy offer <skills>\`** — Offer skills to the community  
+**\`workshop-buddy seeking <skills>\`** — Find people with specific skills
+**\`workshop-buddy matches\`** — Browse community skill exchanges
+
+**Perfect for:**
+- Finding a coding partner with complementary skills
+- Pairing designers with developers
+- Connecting product people with engineers
+- Building cross-functional teams
+
+**Examples:**
+\`workshop-buddy offer "frontend, react, typescript"\`
+\`workshop-buddy seeking "backend, python"\``;
+    }
+  } catch (error) {
+    display = `## Workshop Buddy Error
+
+${error.message}
+
+Try: \`workshop-buddy\` for available commands`;
+  }
+
+  return { display };
+}
+
+module.exports = { definition, handler };