slashvibe-mcp 0.2.8 → 0.3.13

package/tools/ship.js

@@ -90,10 +90,16 @@ async function handler(args) {
       tags.push(`fulfills:${args.for_request}`);
     }
 
-    // Post to board
+    // Post to board (with auth token)
+    const authToken = config.getAuthToken();
+    const headers = { 'Content-Type': 'application/json' };
+    if (authToken) {
+      headers['Authorization'] = `Bearer ${authToken}`;
+    }
+
     const response = await fetch(`${apiUrl}/api/board`, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
+      headers,
       body: JSON.stringify({
         author: myHandle,
         content,
@@ -114,21 +120,38 @@ async function handler(args) {
       patterns.logInspiredBy(args.inspired_by);
     }
 
-    let display = `🚀 shipped\n\n${args.what}`;
+    let display = `🚀 **Shipped!**\n\n${args.what}`;
 
     if (args.url) {
-      display += `\n${args.url}`;
+      display += `\n🔗 ${args.url}`;
     }
     if (args.inspired_by) {
-      display += `\n_via @${args.inspired_by.replace('@', '')}_`;
+      display += `\n✨ _via @${args.inspired_by.replace('@', '')}_`;
+    }
+
+    // Add share URL for viral distribution
+    if (data.shareUrl) {
+      display += `\n\n**📣 Share your ship:**\n${data.shareUrl}`;
+
+      // Use the twitterShareUrl from API response (tracked for K-factor)
+      if (data.twitterShareUrl) {
+        display += `\n\n**🐦 Share on Twitter** (helps others discover /vibe!)`;
+        display += `\n${data.twitterShareUrl}`;
+      } else {
+        // Fallback to inline URL if API didn't return one
+        const shareText = encodeURIComponent(`🚀 Just shipped: ${args.what.substring(0, 80)}\n\nBuilding with /vibe`);
+        const encodedUrl = encodeURIComponent(data.shareUrl);
+        display += `\n\n**Quick share:**`;
+        display += `\n• Twitter: https://twitter.com/intent/tweet?text=${shareText}&url=${encodedUrl}&hashtags=buildinpublic,vibecoders`;
+      }
     }
 
     display += '\n';
-    
+
     // Quiet awareness of similar builders
     const suggestions = await findSimilarShippers(myHandle, args.what);
     if (suggestions.length > 0) {
-      display += `\n_similar: @${suggestions.slice(0, 2).map(s => s.handle).join(', @')}_`;
+      display += `\n_similar builders: @${suggestions.slice(0, 2).map(s => s.handle).join(', @')}_`;
     }
 
     return { display };

package/tools/smart-check.js

@@ -0,0 +1,201 @@
+/**
+ * Smart Inbox Check Tool
+ *
+ * MCP tool for intelligent inbox checking at natural breaks.
+ * Designed to be called by Claude Code after commits, tests, builds, or natural pauses.
+ *
+ * Usage:
+ *   vibe check                     - Explicit check now
+ *   vibe check --after-commit      - Check after a commit
+ *   vibe check --after-test        - Check after test run
+ *   vibe check --after-build       - Check after build
+ *   vibe check --natural           - Check at natural break
+ *   vibe check --stats             - Show check statistics
+ */
+
+const smartInbox = require('../smart-inbox');
+const config = require('../config');
+
+const TOOL_NAME = 'vibe_smart_check';
+
+const toolDefinition = {
+  name: TOOL_NAME,
+  description: `Smart inbox check at natural breaks. Call this after commits, tests, builds, or between tasks. Returns unread messages and notifications. Debounced to avoid spam.
+
+Example triggers:
+- After git commit: trigger="commit", context={message: "feat: add auth"}
+- After test: trigger="test_pass" or trigger="test_fail"
+- After build: trigger="build_complete" or trigger="build_fail"
+- Natural break: trigger="natural" (between tasks, after file saves)
+- Explicit: trigger="explicit" or omit (check now regardless of timing)
+
+The tool debounces checks to avoid notification spam (min 1 minute between checks for same trigger type).`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      trigger: {
+        type: 'string',
+        description: 'What triggered this check',
+        enum: ['explicit', 'commit', 'test_pass', 'test_fail', 'build_complete', 'build_fail', 'natural'],
+        default: 'explicit',
+      },
+      context: {
+        type: 'object',
+        description: 'Optional context about the trigger (commit message, test output, etc.)',
+        properties: {
+          message: { type: 'string', description: 'Commit message or summary' },
+          branch: { type: 'string', description: 'Git branch name' },
+          output: { type: 'string', description: 'Test/build output summary' },
+          file: { type: 'string', description: 'File being worked on' },
+        },
+      },
+      stats: {
+        type: 'boolean',
+        description: 'If true, return check statistics instead of checking inbox',
+        default: false,
+      },
+    },
+    required: [],
+  },
+};
+
+async function handler({ trigger = 'explicit', context = {}, stats = false }) {
+  // Check initialization
+  if (!config.isInitialized()) {
+    return {
+      content: [{
+        type: 'text',
+        text: '❌ Not initialized. Run `vibe init` first.',
+      }],
+    };
+  }
+
+  // Return stats if requested
+  if (stats) {
+    const checkStats = smartInbox.getStats();
+    const lines = [
+      '📊 **Smart Check Statistics**',
+      '',
+      `Last check: ${checkStats.lastCheck || 'Never'}`,
+      `Last trigger: ${checkStats.lastTrigger || 'None'}`,
+      `Total checks: ${checkStats.checkCount}`,
+      `Time since last: ${checkStats.timeSinceLastCheck ? `${checkStats.timeSinceLastCheck}s ago` : 'N/A'}`,
+      '',
+      '**Today\'s triggers:**',
+    ];
+
+    const todayTriggers = checkStats.todayTriggers;
+    if (Object.keys(todayTriggers).length === 0) {
+      lines.push('  (none yet)');
+    } else {
+      for (const [trig, count] of Object.entries(todayTriggers)) {
+        lines.push(`  ${trig}: ${count}`);
+      }
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: lines.join('\n'),
+      }],
+    };
+  }
+
+  // Map trigger strings to constants
+  const triggerMap = {
+    explicit: smartInbox.TRIGGERS.EXPLICIT,
+    commit: smartInbox.TRIGGERS.COMMIT,
+    test_pass: smartInbox.TRIGGERS.TEST_PASS,
+    test_fail: smartInbox.TRIGGERS.TEST_FAIL,
+    build_complete: smartInbox.TRIGGERS.BUILD_COMPLETE,
+    build_fail: smartInbox.TRIGGERS.BUILD_FAIL,
+    natural: smartInbox.TRIGGERS.NATURAL_BREAK,
+  };
+
+  const triggerType = triggerMap[trigger] || smartInbox.TRIGGERS.EXPLICIT;
+
+  // Perform the check
+  const result = await smartInbox.check(triggerType, context);
+
+  // Build response
+  if (!result.checked) {
+    // Check was debounced or skipped
+    const waitSec = Math.ceil((result.waitMs || 0) / 1000);
+    return {
+      content: [{
+        type: 'text',
+        text: `⏳ Skipped (${result.reason})${waitSec > 0 ? ` — try again in ${waitSec}s` : ''}`,
+      }],
+    };
+  }
+
+  // Format the result
+  const lines = [];
+  const handle = config.getHandle();
+
+  // Show what triggered the check
+  const triggerEmoji = {
+    commit: '📝',
+    test_pass: '✅',
+    test_fail: '❌',
+    build_complete: '🏗️',
+    build_fail: '🔴',
+    natural_break: '☕',
+    explicit: '🔔',
+    session_start: '🚀',
+    session_end: '👋',
+  };
+
+  lines.push(`${triggerEmoji[result.trigger] || '📬'} **Inbox check** (${result.trigger})`);
+  lines.push('');
+
+  // Unread messages
+  if (result.unreadCount > 0) {
+    lines.push(`📨 **${result.unreadCount} unread message${result.unreadCount > 1 ? 's' : ''}**`);
+    if (result.notified) {
+      lines.push('  → Notification sent');
+    }
+    lines.push(`  → Open with \`vibe inbox\``);
+  } else {
+    lines.push('📭 No unread messages');
+  }
+
+  // New users online
+  if (result.newOnline && result.newOnline.length > 0) {
+    lines.push('');
+    lines.push(`🟢 **Just came online:** @${result.newOnline.join(', @')}`);
+  }
+
+  // New ships
+  if (result.newShips && result.newShips.length > 0) {
+    lines.push('');
+    lines.push(`🚀 **New ships from connections:** @${result.newShips.join(', @')}`);
+  }
+
+  // Show context if provided
+  if (context.message) {
+    lines.push('');
+    lines.push(`_Context: "${context.message.slice(0, 60)}${context.message.length > 60 ? '...' : ''}"_`);
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: lines.join('\n'),
+    }],
+    // Include structured data for programmatic use
+    _meta: {
+      unreadCount: result.unreadCount,
+      notified: result.notified,
+      newOnline: result.newOnline,
+      newShips: result.newShips,
+      trigger: result.trigger,
+    },
+  };
+}
+
+module.exports = {
+  name: TOOL_NAME,
+  definition: toolDefinition,
+  handler,
+};

package/tools/start.js

@@ -18,6 +18,7 @@ const notify = require('../notify');
 const patterns = require('../intelligence/patterns');
 const { actions, formatActions } = require('./_actions');
 const init = require('./init');
+const { gatherWithTimeout } = require('./_work-context');
 
 const REPO_DIR = path.join(process.env.HOME, '.vibe', 'vibe-repo');
 
@@ -191,7 +192,7 @@ async function handler(args) {
 
   // Step 1: Check if properly authenticated with OAuth
   // If not, redirect to init for GitHub auth flow (shows pre-auth banner + OAuth)
-  if (!config.hasPrivyAuth()) {
+  if (!config.hasOAuth()) {
     return init.handler({
       handle: args.handle,
       one_liner: args.building
@@ -199,7 +200,7 @@ async function handler(args) {
   }
 
   // Step 2: User is authenticated - show dashboard
-  let myHandle = config.getHandle();
+  const myHandle = config.getHandle();
   let threads = [];
   let updateNotice = '';
 
@@ -211,6 +212,32 @@ async function handler(args) {
   // Fetch version info early (non-blocking, cached)
   const versionInfo = await getVersionInfo().catch(() => null);
 
+  // ═══════════════════════════════════════════════════════════════════════
+  // AMBIENT CONTEXT: Gather work context and auto-set presence
+  // ═══════════════════════════════════════════════════════════════════════
+  let workContext = null;
+  const autoContextEnabled = config.get('autoContext', true); // Opt-out via settings
+
+  if (autoContextEnabled) {
+    try {
+      // Gather context with timeout (won't block startup)
+      workContext = await gatherWithTimeout(2000);
+
+      // Auto-set presence so others see what we're working on (silent, non-blocking)
+      if (workContext?.suggestions?.brief) {
+        // Use store.heartbeat directly instead of importing context tool
+        // This avoids circular dependencies and is simpler
+        store.heartbeat(myHandle, config.getOneLiner(), {
+          note: workContext.suggestions.brief,
+          branch: workContext.git?.branch || null
+        }).catch(() => {}); // Silent fail - don't block
+      }
+    } catch (e) {
+      // Silent fail - context is nice-to-have, not required
+      workContext = null;
+    }
+  }
+
   // Log session start for patterns
   patterns.logSessionStart(myHandle);
 
@@ -225,8 +252,12 @@ async function handler(args) {
 
   // Step 3: Check inbox + trigger notifications
   let unreadCount = 0;
+  let inboxThreads = [];
   try {
-    unreadCount = await store.getUnreadCount(myHandle);
+    // Fetch full inbox (not just count) so we can include summaries
+    inboxThreads = await store.getInbox(myHandle);
+    unreadCount = inboxThreads.reduce((sum, t) => sum + (t.unread || 0), 0);
+
     if (unreadCount > 0) {
       // Check for messages needing desktop notification escalation
       const rawInbox = await store.getRawInbox(myHandle).catch(() => []);
@@ -236,6 +267,24 @@ async function handler(args) {
     }
   } catch (e) {}
 
+  // Step 4: Get connection suggestions from API
+  let suggestions = [];
+  try {
+    const apiUrl = config.getApiUrl();
+    const suggestionsResponse = await fetch(`${apiUrl}/api/suggestions?user=${myHandle}&limit=3`, {
+      headers: { 'User-Agent': 'vibe-mcp-client' }
+    });
+
+    if (suggestionsResponse.ok) {
+      const data = await suggestionsResponse.json();
+      if (data.success && data.suggestions) {
+        suggestions = data.suggestions;
+      }
+    }
+  } catch (e) {
+    // Silent fail - suggestions are nice-to-have
+  }
+
   // Generate the ASCII welcome card (matches init.js format)
   const welcomeCard = generateWelcomeCard({
     handle: myHandle,
@@ -247,6 +296,46 @@ async function handler(args) {
   // Build display with card + any additional info
   let display = welcomeCard;
 
+  // Add who's online section (top 5 with what they're building)
+  if (others.length > 0) {
+    const top5 = others.slice(0, 5);
+    display += `\n\n**🟢 Online now:**`;
+    top5.forEach(u => {
+      const status = u.status ? ` (${u.status})` : '';
+      const building = u.one_liner || u.note || '';
+      const truncated = building.length > 40 ? building.slice(0, 40) + '...' : building;
+      display += `\n• @${u.handle}${status}${truncated ? ' — ' + truncated : ''}`;
+    });
+    if (others.length > 5) {
+      display += `\n• _+${others.length - 5} more..._`;
+    }
+  }
+
+  // Add unread messages section (if any)
+  if (unreadCount > 0) {
+    const unreadSenders = inboxThreads.filter(t => t.unread > 0);
+    display += `\n\n**📬 Unread (${unreadCount}):**`;
+    unreadSenders.slice(0, 3).forEach(t => {
+      const preview = t.lastMessage ? t.lastMessage.slice(0, 50) : '';
+      const truncated = preview.length > 50 ? preview + '...' : preview;
+      display += `\n• @${t.handle} (${t.unread}) — "${truncated}"`;
+    });
+    if (unreadSenders.length > 3) {
+      display += `\n• _+${unreadSenders.length - 3} more threads..._`;
+    }
+  }
+
+  // Add connection suggestions (if any)
+  if (suggestions.length > 0) {
+    display += `\n\n**🤝 Suggested connections:**`;
+    suggestions.slice(0, 3).forEach(s => {
+      display += `\n• @${s.handle} — ${s.reason}`;
+      if (s.github_name) {
+        display += ` (${s.github_name})`;
+      }
+    });
+  }
+
   // Add memory context for returning users
   if (threads.length > 0) {
     const recentThreads = threads.slice(0, 3);
@@ -259,17 +348,48 @@ async function handler(args) {
     display += updateNotice;
   }
 
-  // Step 6: Suggest background presence monitor (if not running)
-  const presenceAgentEnabled = config.get('presenceAgentEnabled', true);
-  const presenceAgentRunning = config.get('presenceAgentRunning');
-
-  if (presenceAgentEnabled && !presenceAgentRunning && others.length > 0) {
-    display += `\n\n---\n💡 **Tip:** Say "start presence monitor" for real-time alerts when interesting people come online.`;
-  }
+  // Step 6: Show rotating tips about features
+  const tips = [
+    '💡 **Tip:** Say "vibe stuck" when you need help — others can jump in and assist.',
+    '💡 **Tip:** Use "vibe available \'React, auth\'" to signal you\'re open to chat about topics.',
+    '💡 **Tip:** Use "vibe context --file auth.js" to share what you\'re working on.',
+    '💡 **Tip:** Say "start presence monitor" for real-time alerts when people come online.'
+  ];
+  const tipIndex = Math.floor(Date.now() / 60000) % tips.length; // Rotate every minute
+  display += `\n\n---\n${tips[tipIndex]}`;
 
   // Build response with hints for structured dashboard flow
   const response = { display };
 
+  // === ENRICHED DATA ===
+  // Include full online users list so Claude doesn't need to call vibe_who
+  response.onlineUsers = others.map(u => ({
+    handle: u.handle,
+    building: u.one_liner || u.note || null,
+    status: u.status || null,
+    lastActive: u.lastSeen ? new Date(u.lastSeen).toISOString() : null
+  }));
+
+  // Include unread thread summaries so Claude doesn't need to call vibe_inbox
+  const unreadSenders = inboxThreads.filter(t => t.unread > 0);
+  response.unreadThreads = unreadSenders.map(t => ({
+    handle: t.handle,
+    unread: t.unread,
+    preview: t.lastMessage ? t.lastMessage.slice(0, 80) : null,
+    isAgent: t.isAgent || false
+  }));
+
+  // Include connection suggestions for smart discovery
+  if (suggestions.length > 0) {
+    response.suggestions = suggestions.map(s => ({
+      handle: s.handle,
+      reason: s.reason,
+      githubName: s.github_name || null,
+      lastActive: s.last_active || null,
+      matchScore: s.score || null
+    }));
+  }
+
   // Determine session state and suggest appropriate flow
   let suggestion = null;
 
@@ -304,18 +424,33 @@ async function handler(args) {
 
   if (others.length === 0 && unreadCount === 0) {
     // Empty room
-    actionList = actions.emptyRoom();
+    actionList = actions.emptyRoom({ workContext });
   } else {
     // Normal dashboard
     actionList = actions.dashboard({
       unreadCount,
       onlineUsers: onlineHandles,
-      suggestion
+      suggestion,
+      workContext
     });
   }
 
   response.actions = formatActions(actionList);
 
+  // ═══════════════════════════════════════════════════════════════════════
+  // WORK CONTEXT: Include in response for Claude to use
+  // ═══════════════════════════════════════════════════════════════════════
+  if (workContext?.suggestions?.brief) {
+    response.workContext = {
+      summary: workContext.suggestions.brief,
+      detailed: workContext.suggestions.detailed,
+      project: workContext.project?.name,
+      branch: workContext.git?.branch,
+      recentCommit: workContext.git?.recentCommits?.[0]?.message || null,
+      hasUncommitted: workContext.git?.hasUncommitted || false
+    };
+  }
+
   return response;
 }
 

package/tools/status.js

@@ -1,11 +1,14 @@
 /**
  * vibe status — Set your mood/status
+ *
+ * Now includes away/back functionality (previously vibe_away/vibe_back)
  */
 
 const config = require('../config');
 const store = require('../store');
 const discord = require('../discord');
 const { trackMood } = require('./summarize');
+const { markAway, markBack, getProactiveSummary } = require('../intelligence/proactive');
 
 const MOODS = {
   'shipping': '🔥',
@@ -16,6 +19,8 @@ const MOODS = {
   'deep': '🎧',
   'celebrating': '🎉',
   'struggling': '😤',
+  'away': '☕',    // Merged from vibe_away
+  'back': null,   // Merged from vibe_back (clears status)
   'clear': null
 };
 
@@ -24,13 +29,17 @@ const SPECIAL_MODES = ['guided', 'freeform'];
 
 const definition = {
   name: 'vibe_status',
-  description: 'Set your mood/status. Options: shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, clear',
+  description: 'Set your mood/status. Options: shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, away, back, clear',
   inputSchema: {
     type: 'object',
     properties: {
       mood: {
         type: 'string',
-        description: 'Your mood (shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, clear)'
+        description: 'Your mood (shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, away, back, clear)'
+      },
+      message: {
+        type: 'string',
+        description: 'Optional away message (only used with away mood, e.g., "grabbing coffee")'
       }
     },
     required: ['mood']
@@ -44,8 +53,9 @@ async function handler(args) {
     };
   }
 
-  const { mood } = args;
+  const { mood, message } = args;
   const moodKey = mood.toLowerCase().replace(/[^a-z]/g, '');
+  const handle = config.getHandle();
 
   // Handle special modes (guided/freeform)
   if (moodKey === 'guided') {
@@ -72,18 +82,55 @@ _Say "set status guided" to re-enable interactive menus._`
     };
   }
 
+  // Handle 'away' mood (merged from vibe_away)
+  if (moodKey === 'away') {
+    const awayMessage = message?.trim();
+
+    // Validate message length
+    if (awayMessage && awayMessage.length > 100) {
+      return { display: '⚠️ Away message too long (100 char max)' };
+    }
+
+    // Set away status with optional message
+    await store.setAwayStatus(handle, 'away', awayMessage || null);
+    markAway();
+
+    if (awayMessage) {
+      return { display: `☕ away — "${awayMessage}"` };
+    }
+    return { display: '☕ away' };
+  }
+
+  // Handle 'back' mood (merged from vibe_back)
+  if (moodKey === 'back') {
+    // Clear away status
+    await store.clearAwayStatus(handle);
+
+    let display = '👋 back';
+
+    // Check if anything happened while away
+    const unreadCount = await store.getUnreadCount(handle).catch(() => 0);
+    if (unreadCount > 0) {
+      display += ` — ${unreadCount} unread`;
+    }
+
+    // Mark as back for proactive tracking
+    markBack();
+
+    return { display };
+  }
+
   if (!MOODS.hasOwnProperty(moodKey)) {
     const options = Object.entries(MOODS)
-      .filter(([k, v]) => v)
+      .filter(([k, v]) => v && k !== 'back')  // Exclude 'back' from list (it's a clear action)
       .map(([k, v]) => `${v} ${k}`)
       .join(', ');
     return {
-      display: `Unknown mood. Options: ${options}, or "clear" to remove`
+      display: `Unknown mood. Options: ${options}, or "clear"/"back" to remove`
     };
   }
 
   const emoji = MOODS[moodKey];
-  const handle = config.getHandle();
 
   // Update presence with mood via context
   await store.heartbeat(handle, config.getOneLiner(), { mood: emoji });