slashvibe-mcp 0.3.20 → 0.3.21

package/intelligence/interests.js

@@ -0,0 +1,369 @@
+/**
+ * Interest Inference — Derive interests from live context signals
+ *
+ * Complements static inference (from building descriptions) with DYNAMIC
+ * interests inferred from what users are ACTUALLY doing:
+ * - Current file/module they're editing
+ * - Branch name they're working on
+ * - Activity patterns (shipping, debugging, etc.)
+ *
+ * This creates a more accurate picture of interests that updates in real-time.
+ */
+
+const { getModule, extractBranchTopic } = require('./serendipity');
+
+// Map file modules to interest categories
+const MODULE_TO_INTERESTS = {
+  // Code organization
+  'agents': ['agents', 'ai', 'automation'],
+  'agent': ['agents', 'ai', 'automation'],
+  'mcp': ['agents', 'mcp', 'ai'],
+  'ai': ['ai', 'machine learning'],
+  'ml': ['machine learning', 'ai', 'data science'],
+  'llm': ['ai', 'machine learning'],
+
+  // Web development
+  'api': ['backend', 'api'],
+  'components': ['frontend', 'web development'],
+  'pages': ['frontend', 'web development'],
+  'views': ['frontend', 'web development'],
+  'hooks': ['frontend', 'react'],
+  'store': ['frontend', 'state management'],
+  'redux': ['frontend', 'state management'],
+
+  // Backend
+  'server': ['backend', 'api'],
+  'services': ['backend', 'microservices'],
+  'controllers': ['backend', 'api'],
+  'models': ['backend', 'database'],
+  'db': ['database', 'backend'],
+  'database': ['database', 'backend'],
+
+  // Infrastructure
+  'infra': ['infrastructure', 'devops'],
+  'deploy': ['devops', 'infrastructure'],
+  'docker': ['devops', 'containers'],
+  'k8s': ['devops', 'kubernetes'],
+  'terraform': ['infrastructure', 'devops'],
+  'ci': ['devops', 'automation'],
+
+  // Testing
+  'tests': ['testing', 'quality'],
+  'test': ['testing', 'quality'],
+  '__tests__': ['testing', 'quality'],
+  'spec': ['testing', 'quality'],
+
+  // Mobile
+  'ios': ['mobile development', 'ios'],
+  'android': ['mobile development', 'android'],
+  'mobile': ['mobile development'],
+
+  // Data
+  'data': ['data science', 'analytics'],
+  'analytics': ['analytics', 'data science'],
+
+  // Security
+  'auth': ['security', 'authentication'],
+  'security': ['security'],
+
+  // Tools
+  'tools': ['developer tools'],
+  'cli': ['developer tools', 'cli'],
+  'scripts': ['developer tools', 'automation'],
+
+  // Content
+  'docs': ['documentation', 'writing'],
+  'content': ['content creation'],
+
+  // Games
+  'game': ['game development', 'gaming'],
+  'games': ['game development', 'gaming'],
+
+  // Design
+  'design': ['design', 'creative'],
+  'styles': ['frontend', 'design'],
+  'ui': ['design', 'frontend']
+};
+
+// Map branch topics to interest categories
+const TOPIC_TO_INTERESTS = {
+  'auth': ['security', 'authentication'],
+  'login': ['security', 'authentication'],
+  'signup': ['security', 'authentication'],
+  'user': ['user experience', 'product'],
+  'ui': ['frontend', 'design'],
+  'api': ['backend', 'api'],
+  'db': ['database', 'backend'],
+  'database': ['database', 'backend'],
+  'ml': ['machine learning', 'ai'],
+  'ai': ['ai', 'machine learning'],
+  'agent': ['agents', 'ai', 'automation'],
+  'test': ['testing', 'quality'],
+  'config': ['infrastructure', 'devops'],
+  'payment': ['fintech', 'product'],
+  'email': ['communication', 'backend'],
+  'notification': ['communication', 'product'],
+  'search': ['search', 'backend'],
+  'cache': ['performance', 'backend'],
+  'session': ['backend', 'security'],
+  'deploy': ['devops', 'infrastructure'],
+  'perf': ['performance', 'optimization'],
+  'mobile': ['mobile development'],
+  'social': ['social', 'community']
+};
+
+// Map file extensions to interests
+const EXTENSION_TO_INTERESTS = {
+  '.py': ['python'],
+  '.js': ['javascript'],
+  '.ts': ['typescript'],
+  '.tsx': ['react', 'typescript'],
+  '.jsx': ['react', 'javascript'],
+  '.go': ['go'],
+  '.rs': ['rust'],
+  '.rb': ['ruby'],
+  '.java': ['java'],
+  '.swift': ['swift', 'ios'],
+  '.kt': ['kotlin', 'android'],
+  '.sol': ['solidity', 'web3'],
+  '.vue': ['vue', 'frontend'],
+  '.svelte': ['svelte', 'frontend'],
+  '.css': ['css', 'frontend'],
+  '.scss': ['css', 'frontend'],
+  '.sql': ['sql', 'database'],
+  '.prisma': ['database', 'backend'],
+  '.graphql': ['graphql', 'api'],
+  '.proto': ['grpc', 'backend'],
+  '.yml': ['devops', 'infrastructure'],
+  '.yaml': ['devops', 'infrastructure'],
+  '.tf': ['terraform', 'infrastructure'],
+  '.md': ['documentation', 'writing']
+};
+
+/**
+ * Infer interests from user's current context
+ * Returns array of interests with confidence scores and sources
+ *
+ * @param {Object} context - User's current context
+ * @param {string} context.file - Current file path
+ * @param {string} context.branch - Current branch name
+ * @param {string} context.mood - Current mood/state
+ * @param {string} context.error - Current error (if any)
+ * @returns {Array} Array of { interest, source, confidence }
+ */
+function inferLiveInterests(context) {
+  if (!context) return [];
+
+  const interests = [];
+
+  // 1. Infer from current file/module
+  if (context.file) {
+    const module = getModule(context.file);
+    if (module && MODULE_TO_INTERESTS[module.toLowerCase()]) {
+      const moduleInterests = MODULE_TO_INTERESTS[module.toLowerCase()];
+      interests.push(...moduleInterests.map(i => ({
+        interest: i,
+        source: 'file',
+        confidence: 0.7,
+        detail: `editing ${module}/`
+      })));
+    }
+
+    // Also check file extension
+    const ext = getFileExtension(context.file);
+    if (ext && EXTENSION_TO_INTERESTS[ext]) {
+      interests.push(...EXTENSION_TO_INTERESTS[ext].map(i => ({
+        interest: i,
+        source: 'extension',
+        confidence: 0.5,
+        detail: `working with ${ext} files`
+      })));
+    }
+  }
+
+  // 2. Infer from branch name
+  if (context.branch) {
+    const topic = extractBranchTopic(context.branch);
+    if (topic && TOPIC_TO_INTERESTS[topic]) {
+      interests.push(...TOPIC_TO_INTERESTS[topic].map(i => ({
+        interest: i,
+        source: 'branch',
+        confidence: 0.8,
+        detail: `on ${context.branch}`
+      })));
+    }
+
+    // Special branch patterns
+    if (/agent|mcp|claude/i.test(context.branch)) {
+      interests.push({
+        interest: 'agents',
+        source: 'branch',
+        confidence: 0.9,
+        detail: `agent-related branch`
+      });
+    }
+  }
+
+  // 3. Infer from activity state (mood)
+  if (context.mood) {
+    const moodInterests = inferFromMood(context.mood);
+    interests.push(...moodInterests);
+  }
+
+  // 4. Infer from error (if debugging)
+  if (context.error) {
+    const errorInterests = inferFromError(context.error);
+    interests.push(...errorInterests);
+  }
+
+  // Dedupe and return top interests by confidence
+  return dedupeByConfidence(interests).slice(0, 5);
+}
+
+/**
+ * Infer interests from mood/state
+ */
+function inferFromMood(mood) {
+  const interests = [];
+  const moodLower = (mood || '').toLowerCase();
+
+  if (moodLower.includes('shipping') || moodLower.includes('deploy')) {
+    interests.push({
+      interest: 'shipping',
+      source: 'mood',
+      confidence: 0.6,
+      detail: 'actively shipping'
+    });
+  }
+
+  if (moodLower.includes('debug') || moodLower.includes('fix')) {
+    interests.push({
+      interest: 'debugging',
+      source: 'mood',
+      confidence: 0.6,
+      detail: 'debugging'
+    });
+  }
+
+  return interests;
+}
+
+/**
+ * Infer interests from error messages
+ */
+function inferFromError(error) {
+  const interests = [];
+  const errorLower = (error || '').toLowerCase();
+
+  // Database errors
+  if (/sql|postgres|mysql|mongo|prisma|database/i.test(errorLower)) {
+    interests.push({
+      interest: 'database',
+      source: 'error',
+      confidence: 0.5,
+      detail: 'debugging database issue'
+    });
+  }
+
+  // API errors
+  if (/fetch|axios|api|endpoint|401|403|404|500/i.test(errorLower)) {
+    interests.push({
+      interest: 'api',
+      source: 'error',
+      confidence: 0.5,
+      detail: 'debugging API issue'
+    });
+  }
+
+  // Type errors (TypeScript)
+  if (/type.*error|typescript|cannot assign/i.test(errorLower)) {
+    interests.push({
+      interest: 'typescript',
+      source: 'error',
+      confidence: 0.5,
+      detail: 'debugging type error'
+    });
+  }
+
+  return interests;
+}
+
+/**
+ * Get file extension from path
+ */
+function getFileExtension(filePath) {
+  if (!filePath) return null;
+  const match = filePath.match(/\.[^./]+$/);
+  return match ? match[0].toLowerCase() : null;
+}
+
+/**
+ * Deduplicate interests, keeping highest confidence for each
+ */
+function dedupeByConfidence(interests) {
+  const byInterest = new Map();
+
+  for (const item of interests) {
+    const existing = byInterest.get(item.interest);
+    if (!existing || item.confidence > existing.confidence) {
+      byInterest.set(item.interest, item);
+    }
+  }
+
+  return Array.from(byInterest.values())
+    .sort((a, b) => b.confidence - a.confidence);
+}
+
+/**
+ * Merge live interests with static interests
+ * Prioritizes explicit user-set interests, then adds live context
+ *
+ * @param {Array} staticInterests - User's profile interests
+ * @param {Array} liveInterests - Inferred from current context
+ * @returns {Array} Combined interests with sources
+ */
+function mergeInterests(staticInterests = [], liveInterests = []) {
+  const merged = new Map();
+
+  // Add static interests first (higher priority)
+  for (const interest of staticInterests) {
+    merged.set(interest, {
+      interest,
+      source: 'profile',
+      confidence: 1.0
+    });
+  }
+
+  // Add live interests if not already present
+  for (const item of liveInterests) {
+    if (!merged.has(item.interest)) {
+      merged.set(item.interest, item);
+    }
+  }
+
+  return Array.from(merged.values())
+    .sort((a, b) => b.confidence - a.confidence);
+}
+
+/**
+ * Format live interests for display
+ */
+function formatLiveInterests(interests) {
+  if (!interests || interests.length === 0) return null;
+
+  const live = interests.filter(i => i.source !== 'profile');
+  if (live.length === 0) return null;
+
+  return live.map(i => i.interest).join(', ');
+}
+
+module.exports = {
+  inferLiveInterests,
+  mergeInterests,
+  formatLiveInterests,
+  dedupeByConfidence,
+  // Expose mappings for testing/extension
+  MODULE_TO_INTERESTS,
+  TOPIC_TO_INTERESTS,
+  EXTENSION_TO_INTERESTS
+};

package/notification-emitter.js

@@ -0,0 +1,77 @@
+/**
+ * MCP `list_changed` notification emitter
+ *
+ * Triggers Claude to refresh tool results without reconnection.
+ * Implements debouncing to prevent notification spam.
+ *
+ * This eliminates the need for 30-second polling loops,
+ * reducing API calls by ~90% and providing instant updates.
+ */
+
+class NotificationEmitter {
+  constructor(server) {
+    this.server = server;
+    this.debounceTimers = {};
+  }
+
+  /**
+   * Emit list_changed notification with debouncing
+   * @param {string} reason - Why notification is being sent (for logging/debugging)
+   * @param {number} debounceMs - Debounce window in milliseconds (default: 1000ms)
+   */
+  emitChange(reason, debounceMs = 1000) {
+    // Debounce to prevent notification spam
+    // If we get multiple changes of the same type within the window,
+    // only emit one notification
+    if (this.debounceTimers[reason]) {
+      clearTimeout(this.debounceTimers[reason]);
+    }
+
+    this.debounceTimers[reason] = setTimeout(() => {
+      try {
+        this.server.notification({
+          method: "notifications/list_changed"
+        });
+        delete this.debounceTimers[reason];
+      } catch (e) {
+        // Silent fail - notifications are best-effort
+        // If notification fails, Claude will continue working normally
+      }
+    }, debounceMs);
+  }
+
+  /**
+   * Emit immediately without debouncing
+   * Use for urgent updates like direct mentions
+   */
+  emitImmediate() {
+    try {
+      this.server.notification({
+        method: "notifications/list_changed"
+      });
+    } catch (e) {
+      // Silent fail
+    }
+  }
+
+  /**
+   * Cancel pending notifications for a specific reason
+   * Useful when shutting down or cleaning up
+   */
+  cancel(reason) {
+    if (this.debounceTimers[reason]) {
+      clearTimeout(this.debounceTimers[reason]);
+      delete this.debounceTimers[reason];
+    }
+  }
+
+  /**
+   * Cancel all pending notifications
+   */
+  cancelAll() {
+    Object.values(this.debounceTimers).forEach(timer => clearTimeout(timer));
+    this.debounceTimers = {};
+  }
+}
+
+module.exports = NotificationEmitter;

package/notify.js

@@ -89,6 +89,8 @@ async function checkAndNotify(inbox) {
 
   let notified = false;
 
+  const myHandle = config.getHandle();
+
   for (const msg of inbox) {
     // Skip if already notified
     if (state.notifiedIds.includes(msg.id)) continue;
@@ -96,6 +98,9 @@ async function checkAndNotify(inbox) {
     // Skip if already read
     if (msg.read) continue;
 
+    // Skip messages FROM yourself (don't notify about your own sends)
+    if (myHandle && msg.from?.toLowerCase() === myHandle.toLowerCase()) continue;
+
     const msgTime = new Date(msg.createdAt).getTime();
     const age = now - msgTime;
 
@@ -104,7 +109,6 @@ async function checkAndNotify(inbox) {
     let reason = '';
 
     // Rule 1: Direct mention in message (always if not "off")
-    const myHandle = config.getHandle();
     if (myHandle && msg.text && msg.text.toLowerCase().includes(`@${myHandle}`)) {
       shouldNotify = true;
       reason = 'mention';

package/package.json

@@ -1,31 +1,28 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.3.20",
-  "mcpName": "io.github.VibeCodingInc/vibe-mcp",
-  "description": "Social MCP server - DMs, presence, discovery, and games for AI-assisted developers. Works with Claude Code, Cursor, VS Code, Windsurf, and any MCP client.",
+  "version": "0.3.21",
+  "mcpName": "io.github.vibecodinginc/vibe",
+  "description": "Social layer for Claude Code - DMs, presence, and connection between AI-assisted developers",
   "main": "index.js",
   "bin": {
-    "slashvibe-mcp": "./index.js"
+    "slashvibe-mcp": "./index.js",
+    "vibe-setup": "./setup.js"
   },
   "scripts": {
-    "start": "node index.js"
+    "start": "node index.js",
+    "test": "node --test tools/*.test.js",
+    "test:context": "node --test tools/_work-context.test.js",
+    "lint": "eslint . --ext .js",
+    "lint:fix": "eslint . --ext .js --fix"
   },
   "keywords": [
     "mcp",
-    "mcp-server",
-    "model-context-protocol",
     "claude-code",
-    "cursor",
-    "windsurf",
-    "vscode",
     "vibe",
     "social",
     "developer-tools",
     "ai",
-    "anthropic",
-    "messaging",
-    "presence",
-    "multiplayer"
+    "anthropic"
   ],
   "author": "Seth Goldstein <seth@slashvibe.dev>",
   "license": "MIT",
@@ -42,11 +39,17 @@
   },
   "files": [
     "index.js",
+    "setup.js",
+    "auth-store.js",
+    "auto-update.js",
     "config.js",
     "crypto.js",
     "discord.js",
     "memory.js",
     "notify.js",
+    "notification-emitter.js",
+    "analytics.js",
+    "smart-inbox.js",
     "presence.js",
     "prompts.js",
     "twitter.js",
@@ -55,10 +58,12 @@
     "store/",
     "protocol/",
     "intelligence/",
+    "games/",
+    "bridges/",
     "README.md"
   ],
   "dependencies": {
-    "better-sqlite3": "^11.0.0",
-    "crossword-layout-generator": "^0.1.1"
+    "crossword-layout-generator": "^0.1.1",
+    "node-fetch": "^2.7.0"
   }
 }

package/prompts.js

@@ -68,7 +68,7 @@ function extractPatterns() {
 
   for (const p of prompts) {
     // Normalize: lowercase, replace @handles with @*, replace quoted strings with "*"
-    let normalized = p.prompt.toLowerCase()
+    const normalized = p.prompt.toLowerCase()
       .replace(/@\w+/g, '@*')
       .replace(/"[^"]+"/g, '"*"')
       .replace(/'[^']+'/g, "'*'")

package/protocol/index.js

@@ -307,6 +307,8 @@ function formatPayload(payload) {
       return formatAckPayload(payload);
     case 'artifact':
       return formatArtifactPayload(payload);
+    case 'code':
+      return formatCodePayload(payload);
     default:
       return `📦 _${payload.type} payload_`;
   }
@@ -357,6 +359,74 @@ function formatAckPayload(payload) {
   return `${icon} Acknowledged: ${payload.replyTo} (${status})`;
 }
 
+/**
+ * Format a code snippet payload for display
+ */
+function formatCodePayload(payload) {
+  const lang = payload.language || '';
+  const filename = payload.filename || null;
+  const code = payload.code || '';
+  const description = payload.description || null;
+
+  let display = '📝 **Code Snippet**';
+  if (filename) {
+    display += ` — \`${filename}\``;
+  }
+  if (lang) {
+    display += ` (${lang})`;
+  }
+  display += '\n';
+
+  if (description) {
+    display += `> ${description}\n`;
+  }
+
+  display += `\`\`\`${lang}\n${code}\n\`\`\``;
+
+  return display;
+}
+
+/**
+ * Create a code snippet payload
+ * @param {string} code - The code content
+ * @param {object} options - Options
+ * @param {string} [options.language] - Programming language
+ * @param {string} [options.filename] - Original filename
+ * @param {string} [options.description] - Brief description
+ */
+function createCodePayload(code, options = {}) {
+  return {
+    type: 'code',
+    version: PROTOCOL_VERSION,
+    code,
+    language: options.language || detectLanguage(code),
+    filename: options.filename || null,
+    description: options.description || null,
+  };
+}
+
+/**
+ * Simple language detection based on content patterns
+ */
+function detectLanguage(code) {
+  if (!code) return '';
+
+  // Check for common patterns
+  if (code.includes('import React') || code.includes('useState') || code.includes('useEffect')) return 'jsx';
+  if (code.includes('import ') && code.includes(' from ')) return 'javascript';
+  if (code.includes('async function') || code.includes('await ')) return 'javascript';
+  if (code.includes('def ') && code.includes(':')) return 'python';
+  if (code.includes('func ') && code.includes('()')) return 'go';
+  if (code.includes('fn ') && code.includes('->')) return 'rust';
+  if (code.includes('SELECT ') || code.includes('INSERT INTO')) return 'sql';
+  if (code.includes('<!DOCTYPE') || code.includes('<html')) return 'html';
+  if (code.includes('{') && code.includes(':') && code.includes(';')) return 'css';
+  if (code.startsWith('{') && code.endsWith('}')) return 'json';
+  if (code.startsWith('#!') && code.includes('/bin/')) return 'bash';
+
+  return '';
+}
+
 function formatArtifactPayload(payload) {
   const template = payload.template || 'artifact';
   const templateIcon = template === 'guide' ? '📘' : template === 'learning' ? '💡' : template === 'workspace' ? '🗂️' : '📦';
@@ -422,6 +492,9 @@ module.exports = {
   // Artifact helpers
   createArtifactPayload,
 
+  // Code helpers
+  createCodePayload,
+
   // Schemas (for extension)
   SCHEMAS
 };