slashvibe-mcp 0.2.2 → 0.2.4

package/intelligence/infer.js

@@ -0,0 +1,316 @@
+/**
+ * Smart Detection — Ambient Intelligence for /vibe
+ *
+ * Automatically infers user state from context signals:
+ * - File activity (what they're editing)
+ * - Branch names (fix-, feat-, debug-)
+ * - Error patterns (debugging)
+ * - Session length (deep focus)
+ * - Message activity (social vs focused)
+ *
+ * Inferred states displayed in `vibe who` with (inferred) label
+ */
+
+// State definitions with detection rules
+const STATES = {
+  'github-shipping': {
+    emoji: '🔥',
+    label: 'shipping code',
+    priority: 0,  // Highest priority — real GitHub commits
+    description: 'Active GitHub commits detected'
+  },
+  'deep-focus': {
+    emoji: '🧠',
+    label: 'deep focus',
+    priority: 1,
+    description: 'Long session, minimal messaging'
+  },
+  'shipping': {
+    emoji: '🚀',
+    label: 'shipping',
+    priority: 2,
+    description: 'Active commits, on main/master branch'
+  },
+  'debugging': {
+    emoji: '🐛',
+    label: 'debugging',
+    priority: 3,
+    description: 'Errors present or fix- branch'
+  },
+  'exploring': {
+    emoji: '🔍',
+    label: 'exploring',
+    priority: 4,
+    description: 'Many file switches, few edits'
+  },
+  'stuck': {
+    emoji: '🤔',
+    label: 'might be stuck',
+    priority: 5,
+    description: 'Same file for a while, no commits'
+  },
+  'pairing': {
+    emoji: '👥',
+    label: 'pairing',
+    priority: 6,
+    description: 'Active messaging with one person'
+  },
+  'late-night': {
+    emoji: '🌙',
+    label: 'late night',
+    priority: 7,
+    description: 'Coding after midnight local time'
+  }
+};
+
+/**
+ * Infer user state from context signals
+ *
+ * @param {Object} context - User's context from presence
+ * @param {string} context.file - Current file being edited
+ * @param {string} context.branch - Current git branch
+ * @param {string} context.error - Recent error message
+ * @param {string} context.note - User's note
+ * @param {string} context.mood - Explicit mood (if set)
+ * @param {number} context.sessionStart - Session start timestamp
+ * @param {number} context.lastMessage - Last message timestamp
+ * @param {number} context.messageCount - Messages in last hour
+ * @param {number} context.fileChangeCount - File changes in last 30min
+ * @param {string} context.lastCommit - Last commit timestamp
+ * @returns {Object|null} Inferred state or null if no strong signal
+ */
+function inferState(context = {}) {
+  // If user has explicit mood set, respect it (no inference)
+  if (context.mood && !context.mood_inferred) {
+    return null;
+  }
+
+  const signals = analyzeSignals(context);
+  const candidates = [];
+
+  // Rule: GitHub Shipping (highest priority - real commits are undeniable)
+  // Active GitHub activity detected from cached activity data
+  if (signals.githubShippingMode === 'hot') {
+    candidates.push({
+      state: 'github-shipping',
+      confidence: 0.95,  // Very high - based on actual commits
+      reason: signals.githubCommits > 0
+        ? `${signals.githubCommits} commits recently`
+        : 'active on GitHub'
+    });
+  } else if (signals.githubShippingMode === 'active') {
+    candidates.push({
+      state: 'github-shipping',
+      confidence: 0.85,
+      reason: 'pushing commits'
+    });
+  }
+
+  // Rule: Deep Focus
+  // Long session (2h+), minimal messaging in last hour
+  if (signals.sessionHours >= 2 && signals.messageCount < 2) {
+    candidates.push({
+      state: 'deep-focus',
+      confidence: Math.min(0.9, 0.5 + (signals.sessionHours - 2) * 0.1),
+      reason: `${signals.sessionHours}h session, focused`
+    });
+  }
+
+  // Rule: Debugging
+  // Has error OR on a fix/debug/bug branch
+  if (signals.hasError || signals.isDebugBranch) {
+    const confidence = signals.hasError ? 0.85 : 0.7;
+    const reason = signals.hasError
+      ? 'working through an error'
+      : `on ${context.branch}`;
+    candidates.push({
+      state: 'debugging',
+      confidence,
+      reason
+    });
+  }
+
+  // Rule: Shipping
+  // On main/master, recent commit activity
+  if (signals.isMainBranch && signals.recentCommit) {
+    candidates.push({
+      state: 'shipping',
+      confidence: 0.8,
+      reason: 'deploying to main'
+    });
+  }
+
+  // Rule: Stuck
+  // Same file for 30+ min, no commits
+  if (signals.sameFileDuration >= 30 && !signals.recentCommit) {
+    candidates.push({
+      state: 'stuck',
+      confidence: Math.min(0.7, 0.4 + (signals.sameFileDuration - 30) * 0.01),
+      reason: `${signals.sameFileDuration}min on same file`
+    });
+  }
+
+  // Rule: Exploring
+  // Many file changes, few edits (high switch rate)
+  if (signals.fileChangeCount >= 5 && signals.sessionHours < 1) {
+    candidates.push({
+      state: 'exploring',
+      confidence: 0.65,
+      reason: 'browsing codebase'
+    });
+  }
+
+  // Rule: Late Night
+  // After midnight, before 5am
+  if (signals.isLateNight) {
+    candidates.push({
+      state: 'late-night',
+      confidence: 0.75,
+      reason: 'burning midnight oil'
+    });
+  }
+
+  // Return highest confidence state above threshold
+  if (candidates.length === 0) return null;
+
+  candidates.sort((a, b) => b.confidence - a.confidence);
+  const best = candidates[0];
+
+  // Only return if confidence is high enough
+  if (best.confidence < 0.6) return null;
+
+  const stateInfo = STATES[best.state];
+  return {
+    state: best.state,
+    emoji: stateInfo.emoji,
+    label: stateInfo.label,
+    confidence: best.confidence,
+    reason: best.reason,
+    inferred: true
+  };
+}
+
+/**
+ * Analyze raw context into normalized signals
+ */
+function analyzeSignals(context) {
+  const now = Date.now();
+
+  // Session duration in hours
+  const sessionStart = context.sessionStart || context.firstSeen || now;
+  const sessionHours = (now - sessionStart) / (1000 * 60 * 60);
+
+  // Branch analysis
+  const branch = (context.branch || '').toLowerCase();
+  const isDebugBranch = /^(fix|debug|bug|hotfix)[-_\/]/.test(branch);
+  const isMainBranch = ['main', 'master', 'production', 'prod'].includes(branch);
+
+  // Error present
+  const hasError = Boolean(context.error && context.error.length > 0);
+
+  // Time since last commit (in minutes)
+  const lastCommitTime = context.lastCommit ? new Date(context.lastCommit).getTime() : 0;
+  const minutesSinceCommit = lastCommitTime ? (now - lastCommitTime) / (1000 * 60) : Infinity;
+  const recentCommit = minutesSinceCommit < 30;
+
+  // File stickiness (how long on same file)
+  const sameFileDuration = context.sameFileSince
+    ? (now - context.sameFileSince) / (1000 * 60)
+    : 0;
+
+  // Message activity
+  const messageCount = context.messageCount || 0;
+
+  // File change frequency
+  const fileChangeCount = context.fileChangeCount || 0;
+
+  // Time of day check (local time)
+  const hour = new Date().getHours();
+  const isLateNight = hour >= 0 && hour < 5;
+
+  // GitHub activity signals (from presence enrichment)
+  const github = context.github || {};
+  const githubShippingMode = github.shipping_mode || null;
+  const githubCommits = github.total_commits || 0;
+
+  return {
+    sessionHours: Math.round(sessionHours * 10) / 10,
+    isDebugBranch,
+    isMainBranch,
+    hasError,
+    recentCommit,
+    sameFileDuration: Math.round(sameFileDuration),
+    messageCount,
+    fileChangeCount,
+    isLateNight,
+    // GitHub signals
+    githubShippingMode,
+    githubCommits
+  };
+}
+
+/**
+ * Get display text for inferred state
+ */
+function formatInferredState(inference) {
+  if (!inference) return null;
+  return {
+    display: `${inference.emoji} ${inference.label} _(inferred)_`,
+    short: `${inference.emoji} ${inference.label}`,
+    reason: inference.reason
+  };
+}
+
+/**
+ * Enhance user data with inferred state
+ * Called when building presence list
+ */
+function enhanceUserWithInference(user) {
+  // Build context from user data
+  const context = {
+    file: user.file,
+    branch: user.branch,
+    error: user.error,
+    note: user.note,
+    mood: user.mood,
+    mood_inferred: user.mood_inferred,
+    firstSeen: user.firstSeen,
+    sessionStart: user.firstSeen,
+    messageCount: user.messageCount || 0,
+    fileChangeCount: user.fileChangeCount || 0,
+    sameFileSince: user.sameFileSince,
+    lastCommit: user.lastCommit,
+    // GitHub activity data (from presence enrichment)
+    github: user.github || null
+  };
+
+  const inference = inferState(context);
+
+  if (inference) {
+    return {
+      ...user,
+      mood: inference.emoji,
+      mood_inferred: true,
+      mood_reason: inference.reason,
+      inferred_state: inference.state
+    };
+  }
+
+  return user;
+}
+
+/**
+ * Batch enhance multiple users
+ */
+function enhanceUsersWithInference(users) {
+  return users.map(enhanceUserWithInference);
+}
+
+module.exports = {
+  STATES,
+  inferState,
+  analyzeSignals,
+  formatInferredState,
+  enhanceUserWithInference,
+  enhanceUsersWithInference
+};

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
+};