slashvibe-mcp 0.2.2 → 0.2.4

package/tools/who.js

@@ -12,6 +12,8 @@ const store = require('../store');
 const notify = require('../notify');
 const { formatTimeAgo, requireInit } = require('./_shared');
 const { actions, formatActions } = require('./_actions');
+const { enhanceUsersWithInference } = require('../intelligence/infer');
+const { getTopSerendipity, getAllSerendipity } = require('../intelligence/serendipity');
 
 const definition = {
   name: 'vibe_who',
@@ -22,7 +24,7 @@ const definition = {
   }
 };
 
-// Activity heat based on session signals
+// Activity heat based on session signals + GitHub activity
 function getHeat(user) {
   const lastSeenMs = user.lastSeen;
   const now = Date.now();
@@ -32,40 +34,68 @@ function getHeat(user) {
   if (user.firstSeen) {
     const sessionDuration = (lastSeenMs - new Date(user.firstSeen).getTime()) / 60000;
     if (sessionDuration < 5 && minutesAgo < 2) {
-      return { icon: '✨', label: 'just joined' };
+      return { icon: '✨', label: 'just joined', inferred: false };
     }
   }
 
+  // GitHub activity signals — real commits are high-confidence
+  if (user.github?.shipping_mode === 'hot') {
+    const commits = user.github.total_commits || 0;
+    const label = commits > 0 ? `shipping code (${commits} commits)` : 'shipping code';
+    return { icon: '🔥', label, inferred: false, source: 'github' };
+  }
+  if (user.github?.shipping_mode === 'active') {
+    return { icon: '⚡', label: 'pushing commits', inferred: false, source: 'github' };
+  }
+
+  // Check for inferred state from smart detection
+  if (user.mood_inferred && user.mood) {
+    const inferredLabel = user.inferred_state
+      ? `${user.inferred_state.replace('-', ' ')}`
+      : 'active';
+    return {
+      icon: user.mood,
+      label: inferredLabel,
+      inferred: true,
+      reason: user.mood_reason
+    };
+  }
+
   // Explicit mood takes priority
   if (user.mood === '🔥' || user.mood === '🚀') {
-    return { icon: '🔥', label: 'shipping' };
+    return { icon: '🔥', label: 'shipping', inferred: false };
   }
   if (user.mood === '🐛') {
-    return { icon: '🐛', label: 'debugging' };
+    return { icon: '🐛', label: 'debugging', inferred: false };
   }
   if (user.mood === '🌙') {
-    return { icon: '🌙', label: 'late night' };
+    return { icon: '🌙', label: 'late night', inferred: false };
   }
   if (user.mood === '🧠') {
-    return { icon: '🧠', label: 'deep work' };
+    return { icon: '🧠', label: 'deep work', inferred: false };
   }
 
   // Infer from builderMode
   if (user.builderMode === 'deep-focus') {
-    return { icon: '🧠', label: 'deep focus' };
+    return { icon: '🧠', label: 'deep focus', inferred: false };
   }
   if (user.builderMode === 'shipping') {
-    return { icon: '🔥', label: 'shipping' };
+    return { icon: '🔥', label: 'shipping', inferred: false };
+  }
+
+  // GitHub building mode (lower activity but still coding)
+  if (user.github?.shipping_mode === 'building') {
+    return { icon: '🔨', label: 'building', inferred: false, source: 'github' };
   }
 
   // Default based on recency
   if (minutesAgo < 2) {
-    return { icon: '⚡', label: 'active' };
+    return { icon: '⚡', label: 'active', inferred: false };
   }
   if (minutesAgo < 10) {
-    return { icon: '●', label: null };
+    return { icon: '●', label: null, inferred: false };
   }
-  return { icon: '○', label: 'idle' };
+  return { icon: '○', label: 'idle', inferred: false };
 }
 
 // Format user's current activity
@@ -80,22 +110,34 @@ function formatActivity(user) {
     parts.push(`(${user.branch})`);
   }
 
-  // Error they're stuck on
+  // Error they're stuck on (highest priority - they might need help)
   if (user.error) {
     const shortError = user.error.slice(0, 50) + (user.error.length > 50 ? '...' : '');
     return `⚠️ _stuck on: ${shortError}_`;
   }
 
-  // Note about what they're doing
+  // Combine file + note if both present
+  if (user.note && parts.length > 0) {
+    return `${parts.join(' ')} — _"${user.note}"_`;
+  }
+
+  // Just note
   if (user.note) {
     return `_"${user.note}"_`;
   }
 
-  // File context
+  // Just file context
   if (parts.length > 0) {
     return parts.join(' ');
   }
 
+  // GitHub active repos (if no other context and GitHub connected)
+  if (user.github?.active_repos?.length > 0) {
+    const repos = user.github.active_repos.slice(0, 2);
+    const repoNames = repos.map(r => r.split('/').pop());  // Get just repo name
+    return `pushing to ${repoNames.join(', ')}`;
+  }
+
   // Fall back to one_liner
   return user.one_liner || 'Building something';
 }
@@ -104,7 +146,9 @@ async function handler(args) {
   const initCheck = requireInit();
   if (initCheck) return initCheck;
 
-  const users = await store.getActiveUsers();
+  const rawUsers = await store.getActiveUsers();
+  // Apply smart detection — infer states from context signals
+  const users = enhanceUsersWithInference(rawUsers);
   const myHandle = config.getHandle();
 
   // Check for notifications (presence + messages)
@@ -117,7 +161,7 @@ async function handler(args) {
 _You're the only one here right now..._
 
 🎮 **Challenge someone later**: "play tictactoe with @friend"
-💬 **Ping @seth**: He's probably around somewhere
+💬 **Message @vibe**: Say hello to the platform!
 🔗 **Invite a friend**: Share \`slashvibe.dev\`
 
 _Check back in a bit — builders come and go._`
@@ -138,26 +182,53 @@ _Check back in a bit — builders come and go._`
     active.forEach(u => {
       const isMe = u.handle === myHandle;
       const tag = isMe ? ' _(you)_' : '';
+      const agentBadge = u.is_agent ? ' 🤖' : '';
+      const operatorTag = u.is_agent && u.operator ? ` _(op: @${u.operator})_` : '';
       const heat = getHeat(u);
+      // Keep it clean — state speaks for itself
       const heatLabel = heat.label ? ` ${heat.label}` : '';
       const activity = formatActivity(u);
       const timeAgo = formatTimeAgo(u.lastSeen);
 
-      display += `${heat.icon} **@${u.handle}**${tag}${heatLabel}\n`;
+      display += `${heat.icon} **@${u.handle}**${agentBadge}${tag}${heatLabel}\n`;
+      if (operatorTag) {
+        display += `   ${operatorTag}\n`;
+      }
       display += `   ${activity}\n`;
       display += `   _${timeAgo}_\n\n`;
     });
   }
 
-  // Away section (collapsed)
+  // Away section (expanded with messages if present)
   if (away.length > 0) {
-    display += `---\n`;
-    display += `**Away** (${away.length}): `;
-    display += away.map(u => {
+    display += `---\n\n`;
+    display += `**Away:**\n`;
+
+    // Split into users with away messages and without
+    const withMessage = away.filter(u => u.awayMessage);
+    const withoutMessage = away.filter(u => !u.awayMessage);
+
+    // Show users with custom away messages (expanded)
+    withMessage.forEach(u => {
       const isMe = u.handle === myHandle;
-      return `@${u.handle}${isMe ? ' (you)' : ''}`;
-    }).join(', ');
-    display += '\n\n';
+      const tag = isMe ? ' _(you)_' : '';
+      const timeAgo = formatTimeAgo(u.lastSeen);
+
+      display += `☕ **@${u.handle}**${tag} — _"${u.awayMessage}"_\n`;
+      display += `   _${timeAgo}_\n\n`;
+    });
+
+    // Show auto-away users (collapsed) with 💤
+    if (withoutMessage.length > 0) {
+      withoutMessage.forEach(u => {
+        const isMe = u.handle === myHandle;
+        const tag = isMe ? ' _(you)_' : '';
+        const timeAgo = formatTimeAgo(u.lastSeen);
+
+        display += `💤 **@${u.handle}**${tag} _(auto-away)_\n`;
+        display += `   _${timeAgo}_\n\n`;
+      });
+    }
   }
 
   // Fun quick actions - randomize suggestions
@@ -176,7 +247,7 @@ _Check back in a bit — builders come and go._`
   try {
     const unread = await store.getUnreadCount(myHandle);
     if (unread > 0) {
-      display += `\n\n📬 **${unread} unread** — \`vibe inbox\``;
+      display += `\n\n📬 **NEW MESSAGE — ${unread} UNREAD** — \`vibe inbox\``;
     }
   } catch (e) {}
 
@@ -185,6 +256,18 @@ _Check back in a bit — builders come and go._`
     display += `\n\n_The room is lively today!_ ⚡`;
   }
 
+  // Genesis spots remaining
+  try {
+    const stats = await store.getStats();
+    if (stats.genesis && stats.genesis.genesis_remaining > 0) {
+      display += `\n\n🌱 **${stats.genesis.genesis_remaining} genesis spots left** of ${stats.genesis.genesis_cap}`;
+    } else if (stats.genesis && stats.genesis.genesis_remaining === 0) {
+      display += `\n\n_Genesis is full — ${stats.genesis.total} builders strong_`;
+    }
+  } catch (e) {
+    // Silent fail — genesis display is nice-to-have
+  }
+
   // Build response with optional hints for structured flows
   const response = { display };
 
@@ -233,6 +316,16 @@ _Check back in a bit — builders come and go._`
     response.suggestion = topSuggestion;
   }
 
+  // Serendipity detection — quiet awareness, not loud callouts
+  const myUser = users.find(u => u.handle === myHandle);
+  if (myUser && active.length > 1) {
+    const serendipity = getTopSerendipity(myUser, active);
+    if (serendipity && serendipity.relevance > 0.75) {
+      // Only surface high-confidence matches, and quietly
+      response.serendipity = serendipity;
+    }
+  }
+
   // Add guided mode actions
   const onlineHandles = active.filter(u => u.handle !== myHandle).map(u => u.handle);
   const unreadCount = await store.getUnreadCount(myHandle).catch(() => 0);

package/tools/withdraw.js

@@ -0,0 +1,145 @@
+/**
+ * vibe_withdraw - Withdraw earnings from FeeRouter
+ *
+ * Generates transaction data to withdraw accumulated on-chain earnings.
+ * User must sign and submit the transaction with their wallet.
+ *
+ * Examples:
+ * - "vibe withdraw"
+ * - "withdraw my earnings"
+ * - "claim my on-chain balance"
+ */
+
+const fetch = require('node-fetch');
+const config = require('../config');
+
+const definition = {
+  name: 'vibe_withdraw',
+  description: 'Withdraw accumulated earnings from the FeeRouter. Generates transaction data for you to sign.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      to_address: {
+        type: 'string',
+        description: 'Optional destination address (defaults to your registered payout wallet)'
+      },
+      check_only: {
+        type: 'boolean',
+        description: 'Only check balance without generating withdrawal transaction'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const { to_address, check_only = false } = args;
+
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  const handle = config.getHandle();
+  const token = config.getToken();
+  const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+  try {
+    // Check-only mode
+    if (check_only) {
+      const response = await fetch(
+        `${apiUrl}/api/earnings/withdraw?handle=${encodeURIComponent(handle)}`,
+        {
+          headers: token ? {
+            'Authorization': `Bearer ${token}`
+          } : {}
+        }
+      );
+
+      const result = await response.json();
+
+      if (!response.ok) {
+        return {
+          display: `❌ ${result.error || 'Failed to check balance'}`
+        };
+      }
+
+      const statusEmoji = result.can_withdraw ? '🟢' : '🟡';
+      const action = result.can_withdraw
+        ? 'Run "vibe withdraw" to generate withdrawal transaction.'
+        : result.registered
+          ? 'No balance to withdraw yet.'
+          : 'Register on-chain first: vibe register_onchain';
+
+      return {
+        display: `
+💰 Withdrawal Status: @${handle}
+
+Balance: ${result.balance_eth} ETH
+Registered: ${result.registered ? 'Yes' : 'No'}
+Can Withdraw: ${statusEmoji} ${result.can_withdraw ? 'Yes' : 'No'}
+
+${action}
+        `.trim(),
+        data: result
+      };
+    }
+
+    // Generate withdrawal transaction
+    const response = await fetch(
+      `${apiUrl}/api/earnings/withdraw`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          to_address: to_address || undefined
+        })
+      }
+    );
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      let display = `❌ ${result.error || 'Failed to generate withdrawal'}`;
+      if (result.action) {
+        display += `\n\nNext step: ${result.action}`;
+      }
+      return { display };
+    }
+
+    const destDisplay = result.destination
+      ? `${result.destination.slice(0, 10)}...${result.destination.slice(-8)}`
+      : 'your wallet';
+
+    return {
+      display: `
+💸 Withdrawal Ready: @${handle}
+
+Amount: ${result.balance_display}
+Destination: ${destDisplay}
+Network: ${result.network}
+
+Transaction to sign:
+  To: ${result.transaction.to}
+  Data: ${result.transaction.data?.slice(0, 40)}...
+  Gas: ${result.transaction.gas}
+
+Instructions:
+${result.instructions?.map((i, idx) => `  ${idx + 1}. ${i}`).join('\n')}
+
+Explorer: ${result.explorer}
+      `.trim(),
+      data: result
+    };
+
+  } catch (error) {
+    return {
+      display: `❌ Failed to process withdrawal: ${error.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/wordassociation.js

@@ -0,0 +1,247 @@
+/**
+ * vibe wordassociation — Start or play word association games
+ *
+ * A multiplayer game where players take turns saying words that associate with the previous word.
+ * Build creative chains of connected ideas!
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { createGamePayload } = require('../protocol');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Word association game implementation
+const wordassociation = require('../games/wordassociation');
+
+const definition = {
+  name: 'vibe_wordassociation',
+  description: 'Start or play word association games. Players take turns saying related words.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      word: {
+        type: 'string',
+        description: 'Word to add to the association chain'
+      },
+      join: {
+        type: 'boolean',
+        description: 'Join an existing game'
+      },
+      new: {
+        type: 'boolean',
+        description: 'Start a new game'
+      },
+      invite: {
+        type: 'string',
+        description: 'Invite someone to the game (e.g., @username)'
+      }
+    },
+    required: []
+  }
+};
+
+/**
+ * Find the most recent word association game state in DMs or group context
+ */
+async function getGameState(myHandle) {
+  // For now, we'll store game state in a special "game room" thread with myself
+  // This allows for multiplayer games that persist across sessions
+  const gameRoomHandle = 'wordassociation-room';
+  const thread = await store.getThread(myHandle, gameRoomHandle);
+  
+  // Find the most recent game payload
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const msg = thread[i];
+    if (msg.payload?.type === 'game' && msg.payload?.game === 'wordassociation') {
+      return { gameState: msg.payload.state, thread };
+    }
+  }
+  
+  return { gameState: null, thread };
+}
+
+/**
+ * Save game state to the game room
+ */
+async function saveGameState(myHandle, gameState, action) {
+  const gameRoomHandle = 'wordassociation-room';
+  const payload = createGamePayload('wordassociation', gameState);
+  
+  let message;
+  if (action.type === 'new') {
+    message = 'Started a new word association game!';
+  } else if (action.type === 'join') {
+    message = `@${action.player} joined the game!`;
+  } else if (action.type === 'word') {
+    message = `@${action.player} said "${action.word}"`;
+    if (gameState.gameOver) {
+      message += ' - Game complete! 🎉';
+    }
+  } else {
+    message = 'Game updated';
+  }
+  
+  await store.sendMessage(myHandle, gameRoomHandle, message, 'dm', payload);
+}
+
+/**
+ * Invite someone to play
+ */
+async function invitePlayer(myHandle, targetHandle) {
+  const them = normalizeHandle(targetHandle);
+  const message = `Hey! I started a word association game. Want to join? Use \`vibe wordassociation --join\` to play!`;
+  await store.sendMessage(myHandle, them, message, 'dm');
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { word, join, new: newGame, invite } = args;
+  const myHandle = config.getHandle();
+
+  // Get current game state
+  const { gameState, thread } = await getGameState(myHandle);
+
+  // Handle inviting someone
+  if (invite) {
+    await invitePlayer(myHandle, invite);
+    return {
+      display: `Invited @${normalizeHandle(invite)} to join the word association game! 🧠`
+    };
+  }
+
+  // Handle starting a new game
+  if (newGame) {
+    const newState = wordassociation.createInitialWordAssociationState();
+    const addResult = wordassociation.addPlayer(newState, myHandle);
+    
+    if (addResult.error) {
+      return { display: addResult.error };
+    }
+
+    await saveGameState(myHandle, addResult.gameState, { type: 'new', player: myHandle });
+
+    return {
+      display: `🧠 **New Word Association Game!**\n\n${wordassociation.formatWordAssociationDisplay(addResult.gameState)}\n\nUse \`vibe wordassociation --word [word]\` to start the chain!\nInvite friends with \`vibe wordassociation --invite @username\``
+    };
+  }
+
+  // Handle joining existing game
+  if (join) {
+    if (!gameState) {
+      // Start a new game if none exists
+      const newState = wordassociation.createInitialWordAssociationState();
+      const addResult = wordassociation.addPlayer(newState, myHandle);
+      
+      if (addResult.error) {
+        return { display: addResult.error };
+      }
+
+      await saveGameState(myHandle, addResult.gameState, { type: 'new', player: myHandle });
+
+      return {
+        display: `🧠 **Joined Word Association Game!**\n\n${wordassociation.formatWordAssociationDisplay(addResult.gameState)}\n\nUse \`vibe wordassociation --word [word]\` to start the chain!`
+      };
+    }
+
+    if (gameState.gameOver) {
+      return { display: 'The current game is over. Use `vibe wordassociation --new` to start a fresh game!' };
+    }
+
+    const addResult = wordassociation.addPlayer(gameState, myHandle);
+    
+    if (addResult.error) {
+      return { display: addResult.error };
+    }
+
+    await saveGameState(myHandle, addResult.gameState, { type: 'join', player: myHandle });
+
+    return {
+      display: `🧠 **Joined Word Association Game!**\n\n${wordassociation.formatWordAssociationDisplay(addResult.gameState)}`
+    };
+  }
+
+  // Handle making a word move
+  if (word) {
+    if (!gameState) {
+      return { display: 'No active game! Use `vibe wordassociation --new` to start one, or `vibe wordassociation --join` to join.' };
+    }
+
+    if (gameState.gameOver) {
+      return { display: 'Game is over! Use `vibe wordassociation --new` to start a fresh game.' };
+    }
+
+    // Try to make the move
+    const moveResult = wordassociation.makeMove(gameState, word, myHandle);
+    
+    if (moveResult.error) {
+      return { display: `❌ ${moveResult.error}` };
+    }
+
+    await saveGameState(myHandle, moveResult.gameState, { 
+      type: 'word', 
+      player: myHandle, 
+      word: word 
+    });
+
+    const display = wordassociation.formatWordAssociationDisplay(moveResult.gameState);
+    
+    // Add fun themes if game is complete
+    if (moveResult.gameState.gameOver) {
+      const themes = wordassociation.findThemes(moveResult.gameState);
+      const stats = wordassociation.getGameStats(moveResult.gameState);
+      
+      let extra = '\n\n**Final Stats:**\n';
+      if (stats) {
+        extra += `Total words: ${stats.totalWords}\n`;
+        extra += `Players: ${stats.contributors}\n`;
+        if (themes.length > 0) {
+          extra += `\n**Themes found:** ${themes.join(', ')}`;
+        }
+      }
+      
+      return {
+        display: `🧠 **Word Association**\n\n${display}${extra}\n\nStart a new game with \`vibe wordassociation --new\`!`
+      };
+    }
+
+    return {
+      display: `🧠 **Word Association**\n\n${display}`
+    };
+  }
+
+  // Show current game state
+  if (gameState) {
+    const display = wordassociation.formatWordAssociationDisplay(gameState);
+    
+    if (gameState.gameOver) {
+      const themes = wordassociation.findThemes(gameState);
+      const stats = wordassociation.getGameStats(gameState);
+      
+      let extra = '\n\n**Final Stats:**\n';
+      if (stats) {
+        extra += `Total words: ${stats.totalWords}\n`;
+        extra += `Players: ${stats.contributors}\n`;
+        if (themes.length > 0) {
+          extra += `\n**Themes found:** ${themes.join(', ')}`;
+        }
+      }
+      
+      return {
+        display: `🧠 **Word Association**\n\n${display}${extra}\n\nStart a new game with \`vibe wordassociation --new\`!`
+      };
+    }
+
+    return {
+      display: `🧠 **Word Association**\n\n${display}\n\nUse \`vibe wordassociation --word [word]\` to continue!\nInvite friends: \`vibe wordassociation --invite @username\``
+    };
+  }
+
+  // No active game
+  return {
+    display: `🧠 **Word Association**\n\nNo active game found.\n\n**Commands:**\n• \`vibe wordassociation --new\` - Start a new game\n• \`vibe wordassociation --join\` - Join existing game\n• \`vibe wordassociation --word [word]\` - Add a word\n• \`vibe wordassociation --invite @user\` - Invite someone\n\n**How to play:**\nPlayers take turns saying words that associate with the previous word. Let your creativity flow and see what interesting chains emerge!`
+  };
+}
+
+module.exports = { definition, handler };