slashvibe-mcp 0.2.2 → 0.2.3

package/intelligence/proactive.js

@@ -0,0 +1,358 @@
+/**
+ * Proactive Agent — Background social intelligence
+ *
+ * Generates unprompted social moments:
+ * - "Ships in the night" — what happened while you were away
+ * - Milestone detection — celebrate when someone ships
+ * - Connection nudges — suggest connections based on overlap
+ * - Break suggestions — nudge after long coding sessions
+ * - Welcome wagon — greet newcomers
+ */
+
+const store = require('../store');
+const config = require('../config');
+
+// Thresholds — conservative, non-intrusive
+const CONFIG = {
+  BREAK_SUGGESTION_HOURS: 6,        // Only after 6h (gentle)
+  AWAY_THRESHOLD_MINUTES: 60,       // Consider "away" after 1h
+  RECENT_SHIP_MINUTES: 30,          // "Recent" ship within 30min
+  WELCOME_WINDOW_HOURS: 4,          // Welcome only very new users
+  MIN_SESSIONS_FOR_NUDGE: 5         // High bar for nudges
+};
+
+// Track state for proactive suggestions
+let proactiveState = {
+  lastBreakSuggestion: null,
+  welcomedUsers: new Set(),
+  celebratedShips: new Set(),
+  lastSessionStart: null,
+  wasAway: false,
+  awayStartTime: null
+};
+
+/**
+ * Generate proactive suggestions based on current state
+ *
+ * @param {Object} context - Current user context
+ * @param {Array} activeUsers - All active users
+ * @returns {Array} Array of proactive suggestions
+ */
+async function generateProactiveSuggestions(context = {}) {
+  const suggestions = [];
+  const myHandle = config.getHandle();
+  if (!myHandle) return suggestions;
+
+  try {
+    const activeUsers = await store.getActiveUsers();
+    const now = Date.now();
+
+    // 1. Ships in the night (if returning from away)
+    const shipsInTheNight = await getShipsInTheNight(myHandle, activeUsers);
+    if (shipsInTheNight) {
+      suggestions.push(shipsInTheNight);
+    }
+
+    // 2. Break suggestion (long session)
+    const breakSuggestion = checkBreakSuggestion(context);
+    if (breakSuggestion) {
+      suggestions.push(breakSuggestion);
+    }
+
+    // 3. Welcome wagon (greet newcomers)
+    const welcomes = getWelcomeWagon(myHandle, activeUsers);
+    suggestions.push(...welcomes);
+
+    // 4. Milestone celebration (someone shipped)
+    const milestones = getMilestoneCelebrations(myHandle, activeUsers);
+    suggestions.push(...milestones);
+
+    // 5. Connection nudges (based on overlapping work)
+    const nudges = getConnectionNudges(myHandle, activeUsers);
+    suggestions.push(...nudges);
+
+    return suggestions.filter(s => s !== null);
+  } catch (e) {
+    console.error('[proactive] Error generating suggestions:', e.message);
+    return [];
+  }
+}
+
+/**
+ * "Ships in the Night" — What happened while you were away
+ */
+async function getShipsInTheNight(myHandle, activeUsers) {
+  // Check if user was recently away
+  const wasRecentlyAway = proactiveState.wasAway &&
+    proactiveState.awayStartTime &&
+    (Date.now() - proactiveState.awayStartTime) > CONFIG.AWAY_THRESHOLD_MINUTES * 60 * 1000;
+
+  if (!wasRecentlyAway) return null;
+
+  // Clear the away state
+  proactiveState.wasAway = false;
+  proactiveState.awayStartTime = null;
+
+  // Get recent activity
+  const recentEvents = [];
+
+  for (const user of activeUsers) {
+    if (user.handle === myHandle) continue;
+
+    // Check for recent ships
+    if (user.inferred_state === 'shipping' || user.builderMode === 'shipping') {
+      recentEvents.push({
+        type: 'shipped',
+        handle: user.handle,
+        context: user.note || user.file || 'something cool'
+      });
+    }
+
+    // Check for new users who joined while away
+    if (user.firstSeen) {
+      const joinedAgo = (Date.now() - new Date(user.firstSeen).getTime()) / (1000 * 60);
+      if (joinedAgo < CONFIG.AWAY_THRESHOLD_MINUTES * 2) {
+        recentEvents.push({
+          type: 'joined',
+          handle: user.handle,
+          context: user.one_liner || 'Building something'
+        });
+      }
+    }
+  }
+
+  if (recentEvents.length === 0) return null;
+
+  // Format the summary
+  const shipped = recentEvents.filter(e => e.type === 'shipped');
+  const joined = recentEvents.filter(e => e.type === 'joined');
+
+  let text = '☕ **While you were away:**\n';
+  if (shipped.length > 0) {
+    text += shipped.map(s => `  • @${s.handle} shipped: ${s.context}`).join('\n') + '\n';
+  }
+  if (joined.length > 0) {
+    text += joined.map(j => `  • @${j.handle} joined: ${j.context}`).join('\n');
+  }
+
+  return {
+    type: 'ships_in_the_night',
+    priority: 1,
+    display: text,
+    events: recentEvents
+  };
+}
+
+/**
+ * Break suggestion after long coding session
+ */
+function checkBreakSuggestion(context) {
+  const sessionStart = context.sessionStart || proactiveState.lastSessionStart;
+  if (!sessionStart) return null;
+
+  const sessionHours = (Date.now() - sessionStart) / (1000 * 60 * 60);
+
+  // Check if we've already suggested a break recently
+  if (proactiveState.lastBreakSuggestion) {
+    const hoursSinceLastSuggestion = (Date.now() - proactiveState.lastBreakSuggestion) / (1000 * 60 * 60);
+    if (hoursSinceLastSuggestion < 2) return null; // Don't nag
+  }
+
+  if (sessionHours >= CONFIG.BREAK_SUGGESTION_HOURS) {
+    proactiveState.lastBreakSuggestion = Date.now();
+
+    return {
+      type: 'break_suggestion',
+      priority: 5,
+      display: `_${Math.floor(sessionHours)}h session_`,
+      sessionHours: Math.floor(sessionHours)
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Welcome wagon — greet newcomers
+ */
+function getWelcomeWagon(myHandle, activeUsers) {
+  const welcomes = [];
+
+  for (const user of activeUsers) {
+    if (user.handle === myHandle) continue;
+    if (proactiveState.welcomedUsers.has(user.handle)) continue;
+
+    // Check if user is new (within welcome window)
+    if (user.firstSeen) {
+      const hoursAgo = (Date.now() - new Date(user.firstSeen).getTime()) / (1000 * 60 * 60);
+      if (hoursAgo < CONFIG.WELCOME_WINDOW_HOURS && hoursAgo > 0) {
+        proactiveState.welcomedUsers.add(user.handle);
+
+        welcomes.push({
+          type: 'welcome',
+          priority: 2,
+          handle: user.handle,
+          display: `_@${user.handle} is new_`,
+          building: user.one_liner
+        });
+      }
+    }
+  }
+
+  return welcomes.slice(0, 1); // Only one welcome at a time
+}
+
+/**
+ * Milestone celebrations — someone shipped!
+ */
+function getMilestoneCelebrations(myHandle, activeUsers) {
+  const milestones = [];
+
+  for (const user of activeUsers) {
+    if (user.handle === myHandle) continue;
+
+    // Check for shipping indicators
+    const isShipping = user.inferred_state === 'shipping' ||
+                       user.mood === '🚀' ||
+                       user.builderMode === 'shipping';
+
+    if (isShipping) {
+      const shipKey = `${user.handle}:${Date.now() / (1000 * 60 * 60) | 0}`; // Hourly key
+      if (proactiveState.celebratedShips.has(shipKey)) continue;
+
+      proactiveState.celebratedShips.add(shipKey);
+
+      // Limit cached ships to prevent memory growth
+      if (proactiveState.celebratedShips.size > 100) {
+        const oldest = [...proactiveState.celebratedShips][0];
+        proactiveState.celebratedShips.delete(oldest);
+      }
+
+      milestones.push({
+        type: 'milestone',
+        priority: 3,
+        handle: user.handle,
+        display: `_@${user.handle} shipping_`,
+        context: user.note || user.file
+      });
+    }
+  }
+
+  return milestones.slice(0, 1); // One celebration at a time
+}
+
+/**
+ * Connection nudges based on overlapping interests
+ */
+function getConnectionNudges(myHandle, activeUsers) {
+  // This would ideally use stored interaction history
+  // For now, just suggest based on similar work patterns
+  const nudges = [];
+  const myUser = activeUsers.find(u => u.handle === myHandle);
+  if (!myUser) return nudges;
+
+  for (const user of activeUsers) {
+    if (user.handle === myHandle) continue;
+
+    // Both in same inferred state
+    if (myUser.inferred_state && user.inferred_state &&
+        myUser.inferred_state === user.inferred_state &&
+        ['debugging', 'deep-focus', 'shipping'].includes(myUser.inferred_state)) {
+
+      nudges.push({
+        type: 'connection_nudge',
+        priority: 4,
+        handle: user.handle,
+        display: `\n💫 You and @${user.handle} are both in ${myUser.inferred_state.replace('-', ' ')} mode`,
+        reason: 'same_state'
+      });
+    }
+  }
+
+  return nudges.slice(0, 1); // One nudge at a time
+}
+
+/**
+ * Mark user as away (for ships in the night tracking)
+ */
+function markAway() {
+  proactiveState.wasAway = true;
+  proactiveState.awayStartTime = Date.now();
+}
+
+/**
+ * Mark user as back
+ */
+function markBack() {
+  // Don't clear immediately - let getShipsInTheNight process it first
+}
+
+/**
+ * Set session start time
+ */
+function setSessionStart(timestamp = Date.now()) {
+  proactiveState.lastSessionStart = timestamp;
+}
+
+/**
+ * Get proactive summary for display
+ * Returns formatted string of all relevant suggestions
+ */
+async function getProactiveSummary(context = {}) {
+  const suggestions = await generateProactiveSuggestions(context);
+
+  if (suggestions.length === 0) return '';
+
+  // Sort by priority and format
+  suggestions.sort((a, b) => a.priority - b.priority);
+
+  // Only show top 2 suggestions to avoid overwhelm
+  return suggestions
+    .slice(0, 2)
+    .map(s => s.display)
+    .join('\n');
+}
+
+/**
+ * Check for proactive opportunities on tool calls
+ * Called from main index.js to inject proactive elements
+ */
+async function checkProactiveOpportunities(toolName, args = {}) {
+  // Track away/back transitions
+  if (toolName === 'vibe_away') {
+    markAway();
+  } else if (toolName === 'vibe_back') {
+    // Don't mark back yet - let ships_in_the_night process
+  } else if (toolName === 'vibe_init' || toolName === 'vibe_start') {
+    setSessionStart();
+  }
+
+  // Only generate suggestions for certain tools
+  const socialTools = ['vibe_who', 'vibe_inbox', 'vibe_start'];
+  if (!socialTools.includes(toolName)) {
+    return null;
+  }
+
+  return await getProactiveSummary(args);
+}
+
+module.exports = {
+  generateProactiveSuggestions,
+  getProactiveSummary,
+  checkProactiveOpportunities,
+  markAway,
+  markBack,
+  setSessionStart,
+  // Export state for testing
+  _getState: () => proactiveState,
+  _resetState: () => {
+    proactiveState = {
+      lastBreakSuggestion: null,
+      welcomedUsers: new Set(),
+      celebratedShips: new Set(),
+      lastSessionStart: null,
+      wasAway: false,
+      awayStartTime: null
+    };
+  }
+};

package/intelligence/serendipity.js

@@ -0,0 +1,306 @@
+/**
+ * Serendipity Engine — Surface meaningful coincidences
+ *
+ * Detects when users are working on related things:
+ * - Same file or module
+ * - Similar branch names (both working on auth)
+ * - Same/similar errors
+ * - Related packages/dependencies
+ *
+ * Returns "serendipity moments" that can be surfaced to users
+ */
+
+/**
+ * Find serendipity matches between current user and all others
+ *
+ * @param {Object} currentUser - The user to find matches for
+ * @param {Array} allUsers - All active users
+ * @returns {Array} Serendipity moments sorted by relevance
+ */
+function findSerendipity(currentUser, allUsers) {
+  const matches = [];
+  const myHandle = currentUser.handle;
+
+  for (const other of allUsers) {
+    if (other.handle === myHandle) continue;
+
+    // 1. Same file or module
+    if (currentUser.file && other.file) {
+      const myModule = getModule(currentUser.file);
+      const theirModule = getModule(other.file);
+
+      if (currentUser.file === other.file) {
+        // Exact same file - high signal!
+        matches.push({
+          type: 'same_file',
+          with: other.handle,
+          context: `both editing ${currentUser.file}`,
+          relevance: 0.95,
+          suggestion: `You're both in ${currentUser.file} right now!`,
+          action: 'pair'
+        });
+      } else if (myModule && theirModule && myModule === theirModule) {
+        // Same module/directory
+        matches.push({
+          type: 'same_module',
+          with: other.handle,
+          context: `both working in ${myModule}/`,
+          relevance: 0.75,
+          suggestion: `You're both in the ${myModule} module`,
+          action: 'connect'
+        });
+      }
+    }
+
+    // 2. Similar branch names
+    if (currentUser.branch && other.branch) {
+      const myTopic = extractBranchTopic(currentUser.branch);
+      const theirTopic = extractBranchTopic(other.branch);
+
+      if (myTopic && theirTopic && myTopic === theirTopic) {
+        matches.push({
+          type: 'same_topic',
+          with: other.handle,
+          context: `both working on ${myTopic}`,
+          relevance: 0.8,
+          suggestion: `You're both working on ${myTopic}-related code`,
+          action: 'connect'
+        });
+      }
+    }
+
+    // 3. Similar errors
+    if (currentUser.error && other.error) {
+      const similarity = errorSimilarity(currentUser.error, other.error);
+      if (similarity > 0.6) {
+        matches.push({
+          type: 'same_struggle',
+          with: other.handle,
+          context: `both hitting similar errors`,
+          relevance: 0.85,
+          suggestion: `@${other.handle} is seeing a similar error`,
+          action: 'help',
+          detail: other.error.slice(0, 50)
+        });
+      }
+    }
+
+    // 4. Complementary work (one debugging, one shipping same area)
+    if (currentUser.branch && other.branch) {
+      const myBranchType = getBranchType(currentUser.branch);
+      const theirBranchType = getBranchType(other.branch);
+      const myTopic = extractBranchTopic(currentUser.branch);
+      const theirTopic = extractBranchTopic(other.branch);
+
+      // You're fixing something they're building (or vice versa)
+      if (myTopic === theirTopic && myBranchType !== theirBranchType) {
+        if (myBranchType === 'fix' && theirBranchType === 'feature') {
+          matches.push({
+            type: 'complementary',
+            with: other.handle,
+            context: `you're fixing ${myTopic}, they're building it`,
+            relevance: 0.7,
+            suggestion: `Heads up: @${other.handle} is building ${myTopic} features`,
+            action: 'inform'
+          });
+        }
+      }
+    }
+
+    // 5. Both just joined recently (newbie solidarity)
+    if (isNewUser(currentUser) && isNewUser(other)) {
+      matches.push({
+        type: 'both_new',
+        with: other.handle,
+        context: 'both new to /vibe',
+        relevance: 0.5,
+        suggestion: `@${other.handle} is also new here`,
+        action: 'welcome'
+      });
+    }
+  }
+
+  // Sort by relevance
+  return matches.sort((a, b) => b.relevance - a.relevance);
+}
+
+/**
+ * Extract module/directory from file path
+ */
+function getModule(filePath) {
+  if (!filePath) return null;
+
+  // Handle common patterns
+  const parts = filePath.split('/');
+
+  // Look for meaningful directories
+  const meaningfulDirs = ['src', 'lib', 'app', 'components', 'pages', 'api', 'services', 'utils', 'hooks', 'store', 'models', 'controllers'];
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (meaningfulDirs.includes(parts[i])) {
+      // Return next directory after meaningful one
+      return parts[i + 1] || parts[i];
+    }
+  }
+
+  // Default to parent directory
+  return parts.length >= 2 ? parts[parts.length - 2] : null;
+}
+
+/**
+ * Extract topic from branch name
+ * e.g., "fix-auth-bug" -> "auth"
+ * e.g., "feat/user-profile" -> "user-profile"
+ */
+function extractBranchTopic(branch) {
+  if (!branch) return null;
+
+  // Remove common prefixes
+  const cleaned = branch
+    .replace(/^(fix|feat|feature|bug|hotfix|chore|refactor|docs)[-_\/]?/i, '')
+    .replace(/[-_\/]/g, '-')
+    .toLowerCase();
+
+  // Extract first meaningful segment
+  const parts = cleaned.split('-').filter(p => p.length > 2);
+
+  // Common topic keywords
+  const topics = ['auth', 'user', 'api', 'db', 'database', 'ui', 'test', 'config', 'payment', 'email', 'notification', 'search', 'cache', 'session', 'login', 'signup'];
+
+  // Look for topic keywords
+  for (const part of parts) {
+    if (topics.includes(part)) {
+      return part;
+    }
+  }
+
+  // Return first segment if no topic found
+  return parts[0] || null;
+}
+
+/**
+ * Get branch type (fix, feature, etc.)
+ */
+function getBranchType(branch) {
+  if (!branch) return 'unknown';
+
+  const lower = branch.toLowerCase();
+  if (/^(fix|bug|hotfix)[-_\/]/.test(lower)) return 'fix';
+  if (/^(feat|feature)[-_\/]/.test(lower)) return 'feature';
+  if (/^(chore|refactor)[-_\/]/.test(lower)) return 'chore';
+  if (['main', 'master', 'production', 'prod'].includes(lower)) return 'main';
+
+  return 'feature'; // Default to feature
+}
+
+/**
+ * Calculate similarity between two error messages
+ */
+function errorSimilarity(error1, error2) {
+  if (!error1 || !error2) return 0;
+
+  // Normalize errors
+  const normalize = (err) => err
+    .toLowerCase()
+    .replace(/[0-9]+/g, 'N')        // Replace numbers
+    .replace(/['"`]/g, '')           // Remove quotes
+    .replace(/\s+/g, ' ')            // Normalize whitespace
+    .slice(0, 100);                  // Truncate
+
+  const e1 = normalize(error1);
+  const e2 = normalize(error2);
+
+  if (e1 === e2) return 1.0;
+
+  // Check for common error types
+  const errorTypes = [
+    'TypeError', 'SyntaxError', 'ReferenceError', 'RangeError',
+    'undefined is not', 'cannot read property', 'is not a function',
+    'module not found', 'cannot find module', 'ENOENT', 'ECONNREFUSED'
+  ];
+
+  for (const type of errorTypes) {
+    const typeLower = type.toLowerCase();
+    if (e1.includes(typeLower) && e2.includes(typeLower)) {
+      return 0.7;
+    }
+  }
+
+  // Simple word overlap
+  const words1 = new Set(e1.split(' ').filter(w => w.length > 3));
+  const words2 = new Set(e2.split(' ').filter(w => w.length > 3));
+  const overlap = [...words1].filter(w => words2.has(w)).length;
+  const union = new Set([...words1, ...words2]).size;
+
+  return union > 0 ? overlap / union : 0;
+}
+
+/**
+ * Check if user is new (first seen within last 24 hours)
+ */
+function isNewUser(user) {
+  if (!user.firstSeen) return false;
+
+  const firstSeen = new Date(user.firstSeen).getTime();
+  const hoursAgo = (Date.now() - firstSeen) / (1000 * 60 * 60);
+
+  return hoursAgo < 24;
+}
+
+/**
+ * Format serendipity moment for display
+ */
+function formatSerendipityMoment(moment) {
+  const emoji = {
+    'same_file': '✨',
+    'same_module': '🔗',
+    'same_topic': '🎯',
+    'same_struggle': '🤝',
+    'complementary': '💡',
+    'both_new': '👋'
+  };
+
+  return {
+    emoji: emoji[moment.type] || '💫',
+    text: moment.suggestion,
+    action: moment.action,
+    handle: moment.with,
+    relevance: moment.relevance
+  };
+}
+
+/**
+ * Get top serendipity moment for a user
+ * Returns null if no strong matches
+ */
+function getTopSerendipity(currentUser, allUsers) {
+  const matches = findSerendipity(currentUser, allUsers);
+
+  // Only surface if relevance is high enough
+  if (matches.length === 0 || matches[0].relevance < 0.6) {
+    return null;
+  }
+
+  return formatSerendipityMoment(matches[0]);
+}
+
+/**
+ * Get all serendipity moments above threshold
+ */
+function getAllSerendipity(currentUser, allUsers, minRelevance = 0.5) {
+  const matches = findSerendipity(currentUser, allUsers);
+  return matches
+    .filter(m => m.relevance >= minRelevance)
+    .map(formatSerendipityMoment);
+}
+
+module.exports = {
+  findSerendipity,
+  getTopSerendipity,
+  getAllSerendipity,
+  formatSerendipityMoment,
+  // Utilities for testing
+  getModule,
+  extractBranchTopic,
+  errorSimilarity
+};