slashvibe-mcp 0.2.9 → 0.3.13

package/tools/tag-suggestions.js

@@ -0,0 +1,257 @@
+/**
+ * Smart Interest & Tag Suggestions — Help users discover what to tag themselves with
+ *
+ * Analyzes what someone is building and suggests:
+ * - Interest tags (broad categories: ai, fintech, gaming)
+ * - Skill tags (specific tech: react, python, figma) 
+ * - Discovery hints (who else to connect with)
+ */
+
+const userProfiles = require('../store/profiles');
+
+// Tech stack detection patterns
+const TECH_PATTERNS = {
+  // Frontend
+  'react': ['react', 'jsx', 'create-react-app', 'react native'],
+  'vue': ['vue', 'vuejs', 'vue.js'],
+  'angular': ['angular', 'ng', '@angular'],
+  'svelte': ['svelte', 'sveltekit'],
+  'typescript': ['typescript', 'ts', '.ts', 'tsc'],
+  'javascript': ['javascript', 'js', 'node', 'npm'],
+  
+  // Backend
+  'python': ['python', 'django', 'flask', 'fastapi', 'py'],
+  'node': ['node', 'nodejs', 'express', 'koa'],
+  'go': ['golang', 'go', 'gin', 'fiber'],
+  'rust': ['rust', 'cargo', 'actix', 'warp'],
+  'java': ['java', 'spring', 'maven', 'gradle'],
+  
+  // Data & AI
+  'ai': ['ai', 'llm', 'gpt', 'claude', 'openai', 'machine learning', 'ml'],
+  'data': ['data', 'pandas', 'numpy', 'jupyter', 'sql', 'database'],
+  'ml': ['tensorflow', 'pytorch', 'scikit', 'keras', 'neural'],
+  
+  // Mobile
+  'ios': ['ios', 'swift', 'swiftui', 'xcode', 'iphone', 'ipad'],
+  'android': ['android', 'kotlin', 'java android', 'play store'],
+  'flutter': ['flutter', 'dart'],
+  'react-native': ['react native', 'expo', 'react-native'],
+  
+  // Design
+  'design': ['figma', 'sketch', 'adobe', 'ui', 'ux', 'design'],
+  'frontend': ['css', 'html', 'sass', 'tailwind', 'bootstrap'],
+  
+  // Infrastructure  
+  'devops': ['docker', 'kubernetes', 'aws', 'gcp', 'azure', 'terraform'],
+  'database': ['postgres', 'mysql', 'mongodb', 'redis', 'sqlite'],
+  
+  // Domains
+  'crypto': ['crypto', 'blockchain', 'web3', 'ethereum', 'bitcoin', 'defi'],
+  'gaming': ['game', 'unity', 'unreal', 'godot', 'gamedev'],
+  'fintech': ['fintech', 'payments', 'banking', 'trading', 'finance'],
+  'healthcare': ['health', 'medical', 'biotech', 'pharma'],
+  'ecommerce': ['ecommerce', 'shopify', 'stripe', 'payment'],
+  'saas': ['saas', 'b2b', 'enterprise', 'subscription'],
+  'social': ['social', 'community', 'chat', 'messaging'],
+  'productivity': ['productivity', 'workflow', 'automation', 'tool']
+};
+
+// Interest categories (broader themes)
+const INTEREST_PATTERNS = {
+  'startups': ['startup', 'founder', 'entrepreneurship', 'indie hacker', 'side project'],
+  'open source': ['open source', 'oss', 'github', 'contribute', 'maintainer'],
+  'developer tools': ['dev tool', 'cli', 'vscode', 'editor', 'developer experience'],
+  'automation': ['automation', 'workflow', 'scripting', 'no-code', 'zapier'],
+  'content creation': ['content', 'blog', 'writing', 'video', 'podcast', 'creator'],
+  'education': ['education', 'learning', 'teaching', 'course', 'tutorial'],
+  'remote work': ['remote', 'distributed', 'async', 'nomad', 'wfh'],
+  'indie': ['indie', 'bootstrap', 'solo', 'maker', 'build in public']
+};
+
+// Analyze text and suggest tags
+function suggestTags(buildingText) {
+  if (!buildingText) return { tech: [], interests: [], confidence: 0 };
+  
+  const text = buildingText.toLowerCase();
+  const suggestions = {
+    tech: new Set(),
+    interests: new Set(),
+    matches: []
+  };
+  
+  // Find tech matches
+  for (const [tag, patterns] of Object.entries(TECH_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (text.includes(pattern.toLowerCase())) {
+        suggestions.tech.add(tag);
+        suggestions.matches.push({ tag, pattern, type: 'tech' });
+        break; // Only count once per tag
+      }
+    }
+  }
+  
+  // Find interest matches
+  for (const [interest, patterns] of Object.entries(INTEREST_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (text.includes(pattern.toLowerCase())) {
+        suggestions.interests.add(interest);
+        suggestions.matches.push({ tag: interest, pattern, type: 'interest' });
+        break;
+      }
+    }
+  }
+  
+  // Calculate confidence based on number of matches
+  const totalMatches = suggestions.matches.length;
+  const confidence = Math.min(totalMatches * 20, 100); // Cap at 100%
+  
+  return {
+    tech: Array.from(suggestions.tech).slice(0, 5), // Limit suggestions
+    interests: Array.from(suggestions.interests).slice(0, 3),
+    confidence,
+    matches: suggestions.matches
+  };
+}
+
+// Find similar builders based on tags
+async function findSimilarBuilders(suggestedTags, limit = 3) {
+  const allProfiles = await userProfiles.getAllProfiles();
+  const matches = [];
+  
+  for (const profile of allProfiles) {
+    if (!profile.tags && !profile.interests) continue;
+    
+    let overlap = 0;
+    const overlappingTags = [];
+    
+    // Check tech tag overlap
+    if (profile.tags) {
+      for (const tag of suggestedTags.tech) {
+        if (profile.tags.includes(tag)) {
+          overlap += 2; // Tech overlap is worth more
+          overlappingTags.push(tag);
+        }
+      }
+    }
+    
+    // Check interest overlap  
+    if (profile.interests) {
+      for (const interest of suggestedTags.interests) {
+        if (profile.interests.includes(interest)) {
+          overlap += 1;
+          overlappingTags.push(interest);
+        }
+      }
+    }
+    
+    if (overlap > 0) {
+      matches.push({
+        handle: profile.handle,
+        overlap,
+        overlappingTags,
+        building: profile.building,
+        lastSeen: profile.lastSeen
+      });
+    }
+  }
+  
+  return matches
+    .sort((a, b) => b.overlap - a.overlap)
+    .slice(0, limit);
+}
+
+// Generate tag suggestions for a user
+async function generateSuggestions(handle) {
+  const profile = await userProfiles.getProfile(handle);
+  
+  if (!profile.building) {
+    return {
+      error: 'No building info found. Set what you\'re building first:\n`vibe update building "your project description"`'
+    };
+  }
+  
+  const suggestions = suggestTags(profile.building);
+  const similarBuilders = await findSimilarBuilders(suggestions);
+  
+  // Filter out already set tags
+  const currentTags = new Set([...(profile.tags || []), ...(profile.interests || [])]);
+  const newTechTags = suggestions.tech.filter(t => !currentTags.has(t));
+  const newInterests = suggestions.interests.filter(i => !currentTags.has(i));
+  
+  return {
+    building: profile.building,
+    confidence: suggestions.confidence,
+    currentTags: profile.tags || [],
+    currentInterests: profile.interests || [],
+    suggested: {
+      tech: newTechTags,
+      interests: newInterests
+    },
+    similarBuilders,
+    matches: suggestions.matches
+  };
+}
+
+// Get trending tags across all users
+async function getTrendingTags() {
+  const allTags = await userProfiles.getTrendingTags();
+  const allInterests = await userProfiles.getTrendingInterests();
+  
+  return {
+    popularTags: allTags.slice(0, 10),
+    popularInterests: allInterests.slice(0, 8)
+  };
+}
+
+// Smart tag completion - suggest similar tags based on partial input
+function suggestSimilarTags(partial) {
+  const allTags = Object.keys(TECH_PATTERNS);
+  const allInterests = Object.keys(INTEREST_PATTERNS);
+  
+  const search = partial.toLowerCase();
+  const matches = [];
+  
+  // Exact prefix matches first
+  for (const tag of [...allTags, ...allInterests]) {
+    if (tag.startsWith(search)) {
+      matches.push({ tag, type: allTags.includes(tag) ? 'tech' : 'interest', score: 3 });
+    }
+  }
+  
+  // Substring matches second
+  for (const tag of [...allTags, ...allInterests]) {
+    if (tag.includes(search) && !tag.startsWith(search)) {
+      matches.push({ tag, type: allTags.includes(tag) ? 'tech' : 'interest', score: 2 });
+    }
+  }
+  
+  // Pattern matches third (e.g., "react" matches "react native")
+  for (const [tag, patterns] of [...Object.entries(TECH_PATTERNS), ...Object.entries(INTEREST_PATTERNS)]) {
+    for (const pattern of patterns) {
+      if (pattern.includes(search) && !tag.includes(search)) {
+        matches.push({ 
+          tag, 
+          type: Object.keys(TECH_PATTERNS).includes(tag) ? 'tech' : 'interest', 
+          score: 1, 
+          matchedPattern: pattern 
+        });
+        break;
+      }
+    }
+  }
+  
+  return matches
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 8)
+    .map(m => m.tag);
+}
+
+module.exports = {
+  suggestTags,
+  generateSuggestions,
+  findSimilarBuilders,
+  getTrendingTags,
+  suggestSimilarTags,
+  TECH_PATTERNS,
+  INTEREST_PATTERNS
+};

package/tools/tip.js

@@ -0,0 +1,193 @@
+/**
+ * vibe_tip - Send an instant on-chain USDC tip
+ *
+ * Real crypto tips with instant settlement on Base Sepolia.
+ * No fees - creator gets 100% of the tip.
+ * Gas is sponsored by /vibe.
+ *
+ * Examples:
+ * - "tip @alice $5 for helping debug"
+ * - "send @bob $1 thanks for the intro"
+ * - "vibe tip @charlie 10"
+ *
+ * Preset amounts: $1 (default), $5, $10
+ */
+
+const config = require('../config');
+const { requireInit, normalizeHandle, displayHandle } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
+
+// Preset tip amounts in cents
+const TIP_PRESETS = {
+  1: 100,   // $1
+  5: 500,   // $5
+  10: 1000  // $10
+};
+
+const definition = {
+  name: 'vibe_tip',
+  description: 'Send an instant on-chain USDC tip. 0% fee - creator gets 100%. Gas is sponsored. Amounts: $1 (default), $5, $10.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      to: {
+        type: 'string',
+        description: 'Recipient handle (e.g., @alice)'
+      },
+      amount: {
+        type: 'number',
+        description: 'Amount in USD (1, 5, or 10). Default: 1'
+      },
+      message: {
+        type: 'string',
+        description: 'Optional message to include with the tip'
+      },
+      context: {
+        type: 'object',
+        description: 'Optional context (type: dm_reply|ship|profile|gig_bonus, reference_id)',
+        properties: {
+          type: {
+            type: 'string',
+            enum: ['dm_reply', 'ship', 'profile', 'gig_bonus']
+          },
+          reference_id: {
+            type: 'string'
+          }
+        }
+      }
+    },
+    required: ['to']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { to, message, context } = args;
+  let { amount = 1 } = args;
+
+  const myHandle = config.getHandle();
+  const token = config.getToken();
+
+  if (!token) {
+    return {
+      display: '❌ **Not authenticated**\n\nRun `vibe init` to authenticate with GitHub first.'
+    };
+  }
+
+  // Normalize recipient handle
+  const recipient = normalizeHandle(to);
+  if (!recipient) {
+    return {
+      display: '❌ **Missing recipient**\n\nPlease specify who to tip (e.g., `tip @alice 5`).'
+    };
+  }
+
+  // Validate and normalize amount to preset
+  amount = parseFloat(amount);
+  if (isNaN(amount) || amount <= 0) {
+    amount = 1;
+  }
+
+  // Round to nearest preset
+  let amountCents;
+  if (amount >= 7.5) {
+    amountCents = TIP_PRESETS[10];
+    amount = 10;
+  } else if (amount >= 3) {
+    amountCents = TIP_PRESETS[5];
+    amount = 5;
+  } else {
+    amountCents = TIP_PRESETS[1];
+    amount = 1;
+  }
+
+  // Call instant tip API
+  const apiUrl = config.getApiUrl();
+
+  // Generate idempotency key to prevent duplicate tips from retries
+  // Key is based on: sender + recipient + amount + timestamp (1-minute bucket)
+  const timeBucket = Math.floor(Date.now() / 60000); // 1-minute buckets
+  const idempotencyKey = `${myHandle}:${recipient}:${amountCents}:${timeBucket}`;
+
+  try {
+    const response = await fetch(`${apiUrl}/api/tips/instant`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+        'Idempotency-Key': idempotencyKey
+      },
+      body: JSON.stringify({
+        to: recipient,
+        amount_cents: amountCents,
+        message,
+        context
+      })
+    });
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      // Handle specific error cases
+      if (result.error === 'insufficient_balance') {
+        return {
+          display: `❌ **Insufficient USDC balance**\n\nYou need USDC to tip. Your balance: $${result.balance_usdc}\n\n` +
+            `Get USDC at [bridge.base.org](${result.help_url})`
+        };
+      }
+
+      if (result.error === 'recipient_no_wallet') {
+        return {
+          display: `❌ **${displayHandle(recipient)} can't receive tips yet**\n\n` +
+            `They need to complete their wallet setup first.`
+        };
+      }
+
+      if (result.error === 'rate_limited') {
+        return {
+          display: `⏳ **Rate limit reached**\n\n${result.message}\n\nTry again in ${Math.ceil(result.reset_in_seconds / 60)} minutes.`
+        };
+      }
+
+      return {
+        display: `❌ **Tip failed**\n\n${result.message || 'Please try again.'}`
+      };
+    }
+
+    // Success!
+    let display = `✅ **Tipped ${displayHandle(recipient)} $${amount} USDC**\n\n`;
+
+    display += `💰 Amount: $${amount}.00\n`;
+    display += `📤 To: ${displayHandle(recipient)}\n`;
+    display += `📥 Fee: $0.00 (0%)\n`;
+    display += `✨ Net to creator: $${amount}.00\n`;
+
+    if (message) {
+      display += `\n💬 _"${message}"_\n`;
+    }
+
+    display += `\n🔗 [View on Explorer](${result.explorer_url})`;
+
+    // Build response with actions
+    const response_obj = {
+      display,
+      tx_hash: result.tx_hash,
+      explorer_url: result.explorer_url
+    };
+
+    // Add follow-up actions
+    response_obj.actions = formatActions(actions.afterTip ? actions.afterTip(recipient) : actions.afterDm(recipient));
+
+    return response_obj;
+
+  } catch (error) {
+    console.error('[tip] Error:', error);
+    return {
+      display: `❌ **Tip failed**\n\nError: ${error.message}\n\nPlease try again.`
+    };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/token.js

@@ -0,0 +1,103 @@
+/**
+ * vibe token — Set auth token after GitHub OAuth
+ *
+ * Usage:
+ *   vibe token <paste-token-here>
+ *
+ * After authenticating via GitHub in browser, paste the token here
+ * to complete authentication.
+ */
+
+const config = require('../config');
+const store = require('../store');
+
+const definition = {
+  name: 'vibe_token',
+  description: 'Set your auth token after browser authentication. Use after completing GitHub OAuth in browser.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      token: {
+        type: 'string',
+        description: 'The auth token from browser authentication'
+      }
+    },
+    required: ['token']
+  }
+};
+
+async function handler(args) {
+  const { token } = args;
+
+  if (!token || token.trim().length < 10) {
+    return {
+      display: `❌ **Invalid token**
+
+Please paste the full token from your browser authentication.
+
+If you haven't authenticated yet:
+1. Run \`vibe init @yourhandle\` to start
+2. Open the auth URL in your browser
+3. Complete GitHub authentication
+4. Paste the token here`
+    };
+  }
+
+  // Verify token with server
+  const verification = await store.verifyAuthToken(token.trim());
+
+  if (!verification.valid) {
+    return {
+      display: `❌ **Token verification failed**
+
+Error: ${verification.error}
+
+The token may be expired or invalid. Try authenticating again:
+1. Visit: ${config.getApiUrl()}/api/auth/github?handle=${config.getHandle() || 'yourhandle'}
+2. Complete GitHub authentication
+3. Paste the new token here`
+    };
+  }
+
+  // Save token
+  config.saveAuthToken(token.trim());
+
+  // Update session identity with verified handle
+  const handle = verification.handle;
+  const oneLiner = config.getOneLiner() || 'Building something';
+  config.setSessionIdentity(handle, oneLiner);
+
+  // Update shared config
+  const cfg = config.load();
+  cfg.handle = handle;
+  cfg.one_liner = oneLiner;
+  config.save(cfg);
+
+  // Remove old keypair (security improvement)
+  if (config.hasKeypair()) {
+    config.removeKeypair();
+  }
+
+  // Send initial heartbeat
+  await store.heartbeat(handle, oneLiner);
+
+  return {
+    display: `✅ **Authenticated as @${handle}**
+
+GitHub: @${verification.github || 'linked'}
+Expires: ${verification.expiresAt ? new Date(verification.expiresAt * 1000).toLocaleString() : 'unknown'}
+
+Your messages are now signed server-side (more secure).
+${config.hasKeypair() ? '' : '🔒 Old local keys have been removed.'}
+
+You're ready to vibe! Try:
+• \`vibe who\` — See who's online
+• \`vibe inbox\` — Check messages
+• \`vibe dm @someone "hello"\` — Send a message`,
+    handle,
+    github: verification.github,
+    authMethod: 'github'
+  };
+}
+
+module.exports = { definition, handler };

package/tools/update.js

@@ -49,7 +49,7 @@ async function handler(args) {
     display += `Your install doesn't support automatic updates.\n\n`;
     display += `To update, re-run the installer:\n`;
     display += `\`\`\`\n`;
-    display += `curl -fsSL https://raw.githubusercontent.com/brightseth/vibe/main/install.sh | bash\n`;
+    display += `curl -fsSL https://raw.githubusercontent.com/VibeCodingInc/vibe-mcp/main/install.sh | bash\n`;
     display += `\`\`\`\n\n`;
     display += `This will migrate you to the git-based installer for future updates.\n\n`;
     display += `---\n`;