slashvibe-mcp 0.3.20 → 0.3.21

package/tools/settings.js

@@ -6,13 +6,15 @@
  * - guided: on | off (dashboard mode)
  * - github_activity: on | off (show GitHub shipping status)
  * - github_activity_privacy: full | status_only | off
+ * - mute: 1h | 2h | 4h | forever | off (merged from vibe_mute)
+ * - auto_context: on | off (ambient work context gathering)
  */
 
 const config = require('../config');
 
 const definition = {
   name: 'vibe_settings',
-  description: 'Configure /vibe preferences. Set notification level, toggle guided mode, or enable GitHub activity signals.',
+  description: 'Configure /vibe preferences. Set notification level, toggle guided mode, enable GitHub activity signals, or mute alerts.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -33,6 +35,14 @@ const definition = {
         type: 'string',
         enum: ['full', 'status_only', 'off'],
         description: 'Privacy level: full (repos/commits), status_only (just badge), off'
+      },
+      mute: {
+        type: 'string',
+        description: 'Mute presence alerts: "1h", "2h", "4h", "forever", or "off" to unmute'
+      },
+      auto_context: {
+        type: 'boolean',
+        description: 'Enable/disable automatic work context gathering (git branch, recent commits shown in presence)'
       }
     }
   }
@@ -65,12 +75,68 @@ async function handler(args) {
     changes.push('github activity privacy → **' + args.github_activity_privacy + '**');
   }
 
+  // Handle mute setting (merged from vibe_mute)
+  if (args.mute) {
+    const duration = args.mute;
+
+    // UNMUTE
+    if (duration === 'off' || duration === 'unmute') {
+      config.set('mutedUntil', null);
+      config.set('focusMode', false);
+      changes.push('alerts → **unmuted**');
+    }
+    // MUTE FOREVER
+    else if (duration === 'forever' || duration === 'disable') {
+      config.set('presenceAgentEnabled', false);
+      config.set('mutedUntil', null);
+      changes.push('alerts → **disabled**');
+    }
+    // PARSE DURATION
+    else {
+      let ms = 0;
+      const match = duration.match(/^(\d+)(h|m|min|hour|hours|minutes)$/);
+
+      if (match) {
+        const amount = parseInt(match[1]);
+        const unit = match[2];
+
+        if (unit === 'h' || unit === 'hour' || unit === 'hours') {
+          ms = amount * 60 * 60 * 1000;
+        } else if (unit === 'm' || unit === 'min' || unit === 'minutes') {
+          ms = amount * 60 * 1000;
+        }
+      } else {
+        // Default to 1 hour if can't parse
+        ms = 60 * 60 * 1000;
+      }
+
+      const mutedUntil = Date.now() + ms;
+      config.set('mutedUntil', mutedUntil);
+
+      const until = new Date(mutedUntil).toLocaleTimeString();
+      const durationText = ms >= 3600000
+        ? `${Math.floor(ms / 3600000)} hour${Math.floor(ms / 3600000) > 1 ? 's' : ''}`
+        : `${Math.floor(ms / 60000)} minutes`;
+
+      changes.push(`alerts → **muted for ${durationText}** (until ${until})`);
+    }
+  }
+
+  // Update auto context if provided
+  if (args.auto_context !== undefined) {
+    config.set('autoContext', args.auto_context);
+    changes.push('auto context → **' + (args.auto_context ? 'on' : 'off') + '**');
+  }
+
   // If no args, show current settings
   if (changes.length === 0) {
     const notifications = config.getNotifications();
     const guided = config.getGuidedMode();
     const githubActivity = config.getGithubActivityEnabled();
     const githubPrivacy = config.getGithubActivityPrivacy();
+    const mutedUntil = config.get('mutedUntil');
+    const presenceEnabled = config.get('presenceAgentEnabled') !== false;
+    const autoContext = config.get('autoContext', true); // Default to true
 
     const notifyDesc = {
       all: 'All notifications (messages, mentions, presence)',
@@ -84,21 +150,43 @@ async function handler(args) {
       off: 'Disabled'
     };
 
+    // Determine mute status
+    let muteStatus = 'off';
+    let muteDesc = 'Alerts enabled';
+    if (!presenceEnabled) {
+      muteStatus = 'disabled';
+      muteDesc = 'Presence alerts permanently disabled';
+    } else if (mutedUntil) {
+      const remaining = mutedUntil - Date.now();
+      if (remaining > 0) {
+        const mins = Math.floor(remaining / 60000);
+        const hours = Math.floor(mins / 60);
+        muteStatus = hours > 0 ? `${hours}h ${mins % 60}m` : `${mins}m`;
+        muteDesc = `Muted until ${new Date(mutedUntil).toLocaleTimeString()}`;
+      }
+    }
+
     return {
       display: '## /vibe Settings\n\n' +
         '**Notifications:** ' + notifications + '\n' +
         '_' + notifyDesc[notifications] + '_\n\n' +
         '**Guided Mode:** ' + (guided ? 'on' : 'off') + '\n' +
         '_' + (guided ? 'Shows dashboard menus' : 'Freeform mode') + '_\n\n' +
+        '**Alert Mute:** ' + muteStatus + '\n' +
+        '_' + muteDesc + '_\n\n' +
         '**GitHub Activity:** ' + (githubActivity ? 'on' : 'off') + '\n' +
         '_' + (githubActivity ? 'Shows shipping status from your GitHub commits' : 'Not sharing GitHub activity') + '_\n\n' +
         (githubActivity ? '**GitHub Privacy:** ' + githubPrivacy + '\n_' + privacyDesc[githubPrivacy] + '_\n\n' : '') +
+        '**Auto Context:** ' + (autoContext ? 'on' : 'off') + '\n' +
+        '_' + (autoContext ? 'Git branch & work summary shared in presence' : 'Work context not auto-shared') + '_\n\n' +
         '---\n\n' +
         '**Change settings:**\n' +
         '• "set notifications to mentions" — less noisy\n' +
         '• "turn off guided mode" — no menus\n' +
+        '• "mute for 2h" — silence alerts temporarily\n' +
         '• "enable github activity" — show when you\'re shipping\n' +
-        '• "set github privacy to status_only" — just badge, no details'
+        '• "set github privacy to status_only" — just badge, no details\n' +
+        '• "disable auto context" — stop sharing git branch/work'
     };
   }
 

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