slashvibe-mcp 0.2.3 → 0.2.4

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/package.json

@@ -1,14 +1,16 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.2.3",
-  "mcpName": "io.github.brightseth/vibe",
+  "version": "0.2.4",
+  "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"
   },
   "scripts": {
-    "start": "node index.js"
+    "start": "node index.js",
+    "test": "node --test tools/*.test.js",
+    "test:context": "node --test tools/_work-context.test.js"
   },
   "keywords": [
     "mcp",
@@ -39,6 +41,8 @@
     "discord.js",
     "memory.js",
     "notify.js",
+    "notification-emitter.js",
+    "analytics.js",
     "presence.js",
     "prompts.js",
     "twitter.js",

package/store/api.js

@@ -10,12 +10,30 @@ const https = require('https');
 const http = require('http');
 const config = require('../config');
 const crypto = require('../crypto');
+const authStore = require('../auth-store');
 
 const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
 
 // Default timeout for API requests (10 seconds)
 const REQUEST_TIMEOUT = 10000;
 
+/**
+ * Force reload of config module to pick up auth changes
+ * This clears the require cache and reloads the config from disk
+ */
+function reloadConfig() {
+  try {
+    // Clear the config module from require cache
+    const configPath = require.resolve('../config');
+    delete require.cache[configPath];
+    // Re-require to get fresh module
+    return require('../config');
+  } catch (e) {
+    console.error('[api] Failed to reload config:', e.message);
+    return config;
+  }
+}
+
 function request(method, path, data = null, options = {}) {
   return new Promise((resolve, reject) => {
     const url = new URL(path, API_URL);
@@ -28,8 +46,9 @@ function request(method, path, data = null, options = {}) {
       'User-Agent': 'vibe-mcp/1.0'
     };
 
-    // Add auth token if provided or if we have one stored
-    const token = options.token || config.getAuthToken();
+    // Add auth token: priority is explicit option > in-memory store > config file
+    // authStore is the SOURCE OF TRUTH during runtime (immediate updates from OAuth)
+    const token = options.token || authStore.getToken() || config.getAuthToken();
     if (token && options.auth !== false) {
       headers['Authorization'] = `Bearer ${token}`;
     }
@@ -46,9 +65,45 @@ function request(method, path, data = null, options = {}) {
     const req = client.request(reqOptions, (res) => {
       let body = '';
       res.on('data', chunk => body += chunk);
-      res.on('end', () => {
+      res.on('end', async () => {
         // Handle non-2xx responses
         if (res.statusCode >= 400) {
+          // 401 REFRESH: If unauthorized and haven't retried, try to recover
+          if (res.statusCode === 401 && !options._retried && options.auth !== false) {
+            console.error('[api] 401 received, attempting token refresh...');
+
+            // First, reload config from disk (in case token was saved but not pushed to store)
+            const freshConfig = reloadConfig();
+            const diskToken = freshConfig.getAuthToken();
+
+            // If disk has a different token, sync it to the auth store
+            if (diskToken && diskToken !== authStore.getToken()) {
+              console.error('[api] Found newer token on disk, syncing to auth store...');
+              authStore.setToken(diskToken);
+            }
+
+            // Now check if we have a fresh token to retry with
+            const freshToken = authStore.getToken() || diskToken;
+
+            // Only retry if we got a different/new token
+            if (freshToken && freshToken !== token) {
+              console.error('[api] Found fresh token, retrying request...');
+              try {
+                const retryResult = await request(method, path, data, {
+                  ...options,
+                  token: freshToken,
+                  _retried: true
+                });
+                resolve(retryResult);
+                return;
+              } catch (retryError) {
+                console.error('[api] Retry failed:', retryError.message);
+              }
+            } else {
+              console.error('[api] No fresh token found, not retrying');
+            }
+          }
+
           try {
             const parsed = JSON.parse(body);
             resolve({ success: false, error: parsed.error || `HTTP ${res.statusCode}`, statusCode: res.statusCode });
@@ -198,7 +253,9 @@ async function getActiveUsers() {
     const result = await request('GET', '/api/presence');
     // Combine active and away users
     const users = [...(result.active || []), ...(result.away || [])];
-    return users.map(u => ({
+
+    // Map to normalized format
+    const mappedUsers = users.map(u => ({
       handle: u.username,
       one_liner: u.workingOn,
       lastSeen: new Date(u.lastSeen).getTime(),
@@ -219,6 +276,24 @@ async function getActiveUsers() {
       awayMessage: u.context?.awayMessage || null,
       awayAt: u.context?.awayAt || null
     }));
+
+    // Sync presence data to local profiles (non-blocking)
+    // This enables discovery to find users by what they're building
+    try {
+      const profiles = require('./profiles');
+      profiles.syncFromPresence(mappedUsers).then(synced => {
+        if (synced > 0) {
+          // Auto-infer interests for new/updated profiles
+          profiles.inferMissingInterests().catch(e =>
+            console.error('[presence] interest inference failed:', e.message)
+          );
+        }
+      }).catch(e => console.error('[presence] sync failed:', e.message));
+    } catch (e) {
+      // Non-fatal: profiles module may not be available in some contexts
+    }
+
+    return mappedUsers;
   } catch (e) {
     console.error('Who failed:', e.message);
     return [];
@@ -313,6 +388,12 @@ async function getInbox(handle) {
     // Use unified messages endpoint - returns { inbox, unread, bySender }
     const result = await request('GET', `/api/messages?user=${handle}`);
 
+    // Check for API errors (auth failures, etc.)
+    if (result.success === false) {
+      console.error('[getInbox] API error:', result.error, result.message);
+      return [];
+    }
+
     // Group messages by sender into thread format
     const bySender = result.bySender || {};
     return Object.entries(bySender).map(([sender, messages]) => ({
@@ -657,6 +738,29 @@ async function getArtifact(slug) {
   }
 }
 
+/**
+ * Update an artifact by ID or slug
+ * @param {string} idOrSlug - Artifact ID or slug
+ * @param {Object} artifact - Updated artifact data
+ */
+async function updateArtifact(idOrSlug, artifact) {
+  try {
+    const result = await request('PUT', `/api/artifacts/${idOrSlug}`, artifact);
+
+    if (result.success === false) {
+      return { success: false, error: result.error || 'Update failed' };
+    }
+
+    return {
+      success: true,
+      artifact: result.artifact
+    };
+  } catch (e) {
+    console.error('Update artifact failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
 /**
  * List artifacts
  * @param {Object} options - { scope: 'mine'|'for-me'|'network', handle, limit }
@@ -751,6 +855,7 @@ module.exports = {
   // Artifacts
   createArtifact,
   getArtifact,
+  updateArtifact,
   listArtifacts,
   sendArtifactCard,