slashvibe-mcp 0.2.9 → 0.3.13

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/social-processor.js

@@ -0,0 +1,445 @@
+/**
+ * /vibe Social Events Processor
+ * 
+ * Processes social media events from all platforms (X, Telegram, Discord)
+ * and executes actions based on content analysis.
+ */
+
+const config = require('../config');
+
+/**
+ * Social action patterns and responses
+ */
+const SOCIAL_PATTERNS = {
+  // /vibe commands
+  commands: {
+    'join vibe': 'invite_to_vibe',
+    'what is vibe': 'explain_vibe', 
+    'how to join': 'send_invite_link',
+    'vibe invite': 'send_invite_link',
+    'ship update': 'ask_for_ship_details'
+  },
+  
+  // Intent detection
+  intents: {
+    building: ['building', 'coding', 'developing', 'working on', 'shipping'],
+    learning: ['learning', 'studying', 'tutorial', 'how to', 'need help'],
+    collaboration: ['collaborate', 'pair program', 'work together', 'team up'],
+    feedback: ['feedback', 'review', 'thoughts on', 'what do you think'],
+    sharing: ['check this out', 'built this', 'shipped', 'just made']
+  },
+  
+  // Auto-response triggers
+  triggers: {
+    mention_with_question: /(@\w+.*\?)|(\?.*@\w+)/,
+    product_hunt_launch: /(product hunt)|(launching on ph)|(ph launch)/i,
+    github_share: /github\.com\/[\w-]+\/[\w-]+/,
+    demo_share: /(demo)|(live demo)|(check out).*https?/i
+  }
+};
+
+/**
+ * Process incoming social event
+ */
+async function processSocialEvent(event) {
+  const { platform, type, from, content, metadata } = event;
+  
+  console.log(`[Social] Processing ${type} from @${from.handle} on ${platform}`);
+  
+  const actions = [];
+  
+  try {
+    // 1. Command detection
+    const command = detectCommand(content);
+    if (command) {
+      actions.push({
+        type: 'command',
+        action: SOCIAL_PATTERNS.commands[command],
+        priority: 'high'
+      });
+    }
+    
+    // 2. Intent analysis
+    const intent = analyzeIntent(content);
+    if (intent) {
+      actions.push({
+        type: 'intent',
+        intent,
+        priority: 'medium'
+      });
+    }
+    
+    // 3. Auto-response triggers
+    const trigger = checkTriggers(content);
+    if (trigger) {
+      actions.push({
+        type: 'trigger',
+        trigger,
+        priority: 'low'
+      });
+    }
+    
+    // 4. Platform-specific processing
+    const platformActions = await processPlatformSpecific(platform, type, event);
+    actions.push(...platformActions);
+    
+    // 5. Execute actions
+    const results = [];
+    for (const action of actions) {
+      const result = await executeAction(action, event);
+      if (result) results.push(result);
+    }
+    
+    return {
+      processed: true,
+      actions_taken: results.length,
+      actions: results
+    };
+    
+  } catch (error) {
+    console.error('[Social] Processing error:', error);
+    return {
+      processed: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Detect /vibe commands in text
+ */
+function detectCommand(text) {
+  const lowerText = text.toLowerCase();
+  
+  for (const [phrase, action] of Object.entries(SOCIAL_PATTERNS.commands)) {
+    if (lowerText.includes(phrase)) {
+      return phrase;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Analyze user intent from message content
+ */
+function analyzeIntent(text) {
+  const lowerText = text.toLowerCase();
+  
+  for (const [intent, keywords] of Object.entries(SOCIAL_PATTERNS.intents)) {
+    for (const keyword of keywords) {
+      if (lowerText.includes(keyword)) {
+        return intent;
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Check for auto-response triggers
+ */
+function checkTriggers(text) {
+  for (const [trigger, pattern] of Object.entries(SOCIAL_PATTERNS.triggers)) {
+    if (pattern.test(text)) {
+      return trigger;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Platform-specific event processing
+ */
+async function processPlatformSpecific(platform, type, event) {
+  const actions = [];
+  
+  switch (platform) {
+    case 'x':
+      if (type === 'mention') {
+        actions.push({ type: 'notify_team', platform: 'x', priority: 'medium' });
+        
+        // If mention contains @vibebuilders or #vibe, flag for team attention
+        if (event.content.includes('@vibebuilders') || event.content.includes('#vibe')) {
+          actions.push({ type: 'team_alert', priority: 'high' });
+        }
+      }
+      
+      if (type === 'dm') {
+        // Auto-reply to DMs with basic info
+        actions.push({ type: 'auto_reply', template: 'dm_welcome', priority: 'high' });
+      }
+      break;
+      
+    case 'telegram':
+      if (type === 'message' && event.metadata?.isGroup) {
+        // Group message - log but don't auto-respond
+        actions.push({ type: 'log_group_activity', priority: 'low' });
+      }
+      break;
+      
+    case 'discord':
+      if (type === 'slash_command') {
+        // Discord commands are handled by the webhook directly
+        actions.push({ type: 'log_command_usage', priority: 'low' });
+      }
+      break;
+  }
+  
+  return actions;
+}
+
+/**
+ * Execute a social action
+ */
+async function executeAction(action, originalEvent) {
+  const { type, priority } = action;
+  
+  try {
+    switch (type) {
+      case 'command':
+        return await handleCommand(action.action, originalEvent);
+        
+      case 'intent':
+        return await handleIntent(action.intent, originalEvent);
+        
+      case 'auto_reply':
+        return await sendAutoReply(action.template, originalEvent);
+        
+      case 'notify_team':
+        return await notifyTeam(originalEvent);
+        
+      case 'team_alert':
+        return await sendTeamAlert(originalEvent);
+        
+      default:
+        console.log(`[Social] Action ${type} logged`);
+        return { action: type, status: 'logged' };
+    }
+  } catch (error) {
+    console.error(`[Social] Action ${type} failed:`, error);
+    return { action: type, status: 'failed', error: error.message };
+  }
+}
+
+/**
+ * Handle /vibe commands
+ */
+async function handleCommand(command, event) {
+  const { platform, from } = event;
+  
+  switch (command) {
+    case 'invite_to_vibe':
+      return await sendVibeInvite(platform, from);
+      
+    case 'explain_vibe':
+      return await sendVibeExplanation(platform, from);
+      
+    case 'send_invite_link':
+      return await sendInviteLink(platform, from);
+      
+    case 'ask_for_ship_details':
+      return await askShipDetails(platform, from);
+      
+    default:
+      return { command, status: 'unknown' };
+  }
+}
+
+/**
+ * Handle user intents
+ */
+async function handleIntent(intent, event) {
+  const suggestions = {
+    building: "That's awesome! Consider sharing your progress in /vibe for feedback and collaboration.",
+    learning: "Learning is great! Check out /vibe's workshop resources and connect with other learners.",
+    collaboration: "Perfect mindset! /vibe is all about collaborative building. Join us!",
+    feedback: "Feedback is valuable! /vibe has active builders who love reviewing each other's work.",
+    sharing: "Love the sharing spirit! /vibe is a great place to showcase what you build."
+  };
+  
+  return {
+    intent,
+    suggestion: suggestions[intent] || "Thanks for sharing!",
+    status: 'processed'
+  };
+}
+
+/**
+ * Send auto-reply based on template
+ */
+async function sendAutoReply(template, event) {
+  const templates = {
+    dm_welcome: `Hi! Thanks for reaching out. /vibe is a collaborative workshop where builders ship cool projects together. 
+
+🚀 Join us: https://slashvibe.dev
+🎮 Try features: Chess, Streaks, Matching
+💬 Connect: @vibebuilders
+
+What are you building?`
+  };
+  
+  const message = templates[template];
+  if (!message) return null;
+  
+  // In a full implementation, this would send the reply via the platform API
+  console.log(`[Social] Auto-reply to @${event.from.handle}: ${message.slice(0, 50)}...`);
+  
+  return {
+    type: 'auto_reply',
+    template,
+    recipient: event.from.handle,
+    status: 'sent'
+  };
+}
+
+/**
+ * Send /vibe invite
+ */
+async function sendVibeInvite(platform, user) {
+  const invite = {
+    message: `🎉 You're invited to /vibe!\n\nA collaborative workshop where builders ship together.\n\n🔗 Join: https://slashvibe.dev\n\nSee you in the workshop! 🚀`,
+    platform,
+    user: user.handle
+  };
+  
+  console.log(`[Social] Sent /vibe invite to @${user.handle} on ${platform}`);
+  
+  return {
+    type: 'invite',
+    recipient: user.handle,
+    platform,
+    status: 'sent'
+  };
+}
+
+/**
+ * Send /vibe explanation
+ */
+async function sendVibeExplanation(platform, user) {
+  const explanation = `✨ /vibe is a collaborative workshop where builders ship cool projects together!
+
+🎯 What we do:
+• Build games (Chess, Drawing, Icebreakers)  
+• Track progress (Streaks, Achievements)
+• Connect builders (Matching, Skills Exchange)
+• Ship fast (Real-time collaboration)
+
+🚀 Join the workshop: https://slashvibe.dev`;
+  
+  console.log(`[Social] Sent /vibe explanation to @${user.handle} on ${platform}`);
+  
+  return {
+    type: 'explanation',
+    recipient: user.handle,
+    platform,
+    status: 'sent'
+  };
+}
+
+/**
+ * Send invite link
+ */
+async function sendInviteLink(platform, user) {
+  return {
+    type: 'invite_link',
+    link: 'https://slashvibe.dev',
+    recipient: user.handle,
+    platform,
+    status: 'sent'
+  };
+}
+
+/**
+ * Ask for ship details
+ */
+async function askShipDetails(platform, user) {
+  const response = `🚀 Awesome that you're shipping! 
+
+What did you build? Tell us about:
+• What it does
+• Tech stack used  
+• Any challenges you solved
+
+We love celebrating builders in /vibe! 🎉`;
+  
+  return {
+    type: 'ship_inquiry',
+    message: response,
+    recipient: user.handle,
+    platform,
+    status: 'sent'
+  };
+}
+
+/**
+ * Notify team about social activity
+ */
+async function notifyTeam(event) {
+  const notification = {
+    type: 'team_notification',
+    event_type: event.type,
+    platform: event.platform,
+    from: event.from.handle,
+    content: event.content.slice(0, 100),
+    timestamp: new Date().toISOString()
+  };
+  
+  console.log('[Social] Team notification:', notification);
+  
+  // In a full implementation, this would send to team channels
+  return {
+    type: 'team_notification',
+    status: 'sent'
+  };
+}
+
+/**
+ * Send high-priority team alert
+ */
+async function sendTeamAlert(event) {
+  const alert = {
+    type: 'team_alert',
+    priority: 'high',
+    event_type: event.type,
+    platform: event.platform,
+    from: event.from.handle,
+    content: event.content,
+    timestamp: new Date().toISOString(),
+    requires_response: true
+  };
+  
+  console.log('[Social] HIGH PRIORITY TEAM ALERT:', alert);
+  
+  // In a full implementation, this would ping the team immediately
+  return {
+    type: 'team_alert',
+    priority: 'high',
+    status: 'sent'
+  };
+}
+
+/**
+ * Get social activity summary
+ */
+async function getSocialSummary() {
+  // This would fetch from KV store in a full implementation
+  return {
+    platforms_active: ['x', 'telegram', 'discord'],
+    events_today: 0, // Would be calculated from KV
+    auto_responses_sent: 0,
+    team_notifications: 0,
+    top_intents: ['building', 'learning', 'collaboration']
+  };
+}
+
+module.exports = {
+  processSocialEvent,
+  detectCommand,
+  analyzeIntent,
+  checkTriggers,
+  getSocialSummary,
+  SOCIAL_PATTERNS
+};

package/tools/solo-game.js

@@ -16,7 +16,7 @@ const memory = require('../games/memory');
 
 // Post game results to board
 async function postSoloGameResult(player, game, won, score = null) {
-  const API_URL = process.env.VIBE_API_URL || 'https://slashvibe.dev';
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
 
   try {
     let content;