slashvibe-mcp 0.2.2 → 0.2.4

package/tools/games-catalog.js

@@ -0,0 +1,376 @@
+/**
+ * vibe games — Discover and launch all available games on /vibe
+ * 
+ * Your one-stop shop for finding fun! Browse all games, get recommendations,
+ * and quick-launch your favorites.
+ */
+
+const config = require('../config');
+const { requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_games',
+  description: 'Discover all available games on /vibe. Browse catalog, get recommendations, quick-launch games.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      category: {
+        type: 'string',
+        description: 'Filter by game category',
+        enum: ['all', 'solo', 'multiplayer', 'collaborative', 'party', 'creative']
+      },
+      players: {
+        type: 'number',
+        description: 'Filter by number of players (1 for solo, 2+ for multiplayer)'
+      },
+      mood: {
+        type: 'string',
+        description: 'Get game recommendations based on your mood',
+        enum: ['competitive', 'creative', 'chill', 'brainy', 'social']
+      }
+    },
+    required: []
+  }
+};
+
+// Games catalog with all available games
+const GAMES_CATALOG = {
+  // Solo Games
+  solo: [
+    {
+      name: '20 Questions',
+      command: 'vibe twenty-questions',
+      description: 'I think of something, you guess with yes/no questions',
+      emoji: '❓',
+      difficulty: 'medium',
+      playtime: '5-10 min',
+      tags: ['brainy', 'solo', 'guessing']
+    },
+    {
+      name: 'Riddles',
+      command: 'vibe riddle',
+      description: 'Challenge your mind with brain teasers across difficulty levels',
+      emoji: '🧩',
+      difficulty: 'varies',
+      playtime: '3-15 min',
+      tags: ['brainy', 'solo', 'puzzle']
+    },
+    {
+      name: 'Hangman',
+      command: 'vibe hangman',
+      description: 'Classic word guessing game - can you save the stick figure?',
+      emoji: '🎪',
+      difficulty: 'easy',
+      playtime: '5 min',
+      tags: ['casual', 'solo', 'word']
+    },
+    {
+      name: 'Number Guessing',
+      command: 'vibe guessnumber',
+      description: 'Guess my number between 1-100 with strategic hints',
+      emoji: '🔢',
+      difficulty: 'easy',
+      playtime: '3-5 min',
+      tags: ['casual', 'solo', 'logic']
+    }
+  ],
+
+  // 1v1 Games
+  versus: [
+    {
+      name: 'Tic-Tac-Toe',
+      command: 'vibe game @friend',
+      description: 'Classic 3x3 grid strategy - get three in a row!',
+      emoji: '⭕',
+      players: 2,
+      difficulty: 'easy',
+      playtime: '2 min',
+      tags: ['competitive', '1v1', 'classic']
+    },
+    {
+      name: 'Chess',
+      command: 'vibe game @friend --game chess',
+      description: 'The timeless strategy game with full piece movement',
+      emoji: '♟️',
+      players: 2,
+      difficulty: 'hard',
+      playtime: '10-60 min',
+      tags: ['competitive', '1v1', 'strategy']
+    },
+    {
+      name: 'Rock Paper Scissors',
+      command: 'vibe rockpaperscissors @friend',
+      description: 'Quick decision game of chance and psychology',
+      emoji: '✂️',
+      players: 2,
+      difficulty: 'easy',
+      playtime: '1 min',
+      tags: ['competitive', '1v1', 'quick']
+    }
+  ],
+
+  // Collaborative & Creative Games
+  collaborative: [
+    {
+      name: 'Collaborative Drawing',
+      command: 'vibe drawing --action start',
+      description: '🎨 Real-time shared canvas! Draw together with emojis and Unicode art',
+      emoji: '🎨',
+      players: '1-8',
+      difficulty: 'easy',
+      playtime: '10-30 min',
+      tags: ['creative', 'collaborative', 'art', 'realtime']
+    },
+    {
+      name: 'Story Builder',
+      command: 'vibe story-builder --action create',
+      description: '📖 Build stories together! Each person adds one sentence',
+      emoji: '📖',
+      players: '1-8',
+      difficulty: 'easy',
+      playtime: '15-30 min',
+      tags: ['creative', 'collaborative', 'writing', 'storytelling']
+    }
+  ],
+
+  // Multiplayer Party Games  
+  party: [
+    {
+      name: 'Word Association',
+      command: 'vibe multiplayer-game wordassociation --action create',
+      description: 'Say words that relate to the previous word. Build themes together!',
+      emoji: '💭',
+      players: '2-6',
+      difficulty: 'easy',
+      playtime: '10-20 min',
+      tags: ['social', 'party', 'word', 'creative']
+    },
+    {
+      name: 'Werewolf',
+      command: 'vibe werewolf --action create',
+      description: 'Social deduction party game - find the werewolves!',
+      emoji: '🐺',
+      players: '5-12',
+      difficulty: 'medium',
+      playtime: '20-45 min',
+      tags: ['social', 'party', 'deduction', 'strategy']
+    },
+    {
+      name: 'Two Truths and a Lie',
+      command: 'vibe twotruths',
+      description: 'Share facts about yourself - others guess which is the lie',
+      emoji: '🤥',
+      players: '3+',
+      difficulty: 'easy',
+      playtime: '10-20 min',
+      tags: ['social', 'party', 'icebreaker']
+    }
+  ]
+};
+
+// Mood-based game recommendations
+const MOOD_RECOMMENDATIONS = {
+  competitive: ['Chess', 'Tic-Tac-Toe', 'Rock Paper Scissors', 'Werewolf'],
+  creative: ['Collaborative Drawing', 'Story Builder', 'Word Association'],
+  chill: ['20 Questions', 'Hangman', 'Number Guessing', 'Two Truths and a Lie'],
+  brainy: ['Riddles', '20 Questions', 'Chess', 'Werewolf'],
+  social: ['Word Association', 'Story Builder', 'Werewolf', 'Two Truths and a Lie', 'Collaborative Drawing']
+};
+
+// Quick stats about the game ecosystem
+function getGameStats() {
+  const allGames = Object.values(GAMES_CATALOG).flat();
+  const totalGames = allGames.length;
+  
+  const byCategory = {};
+  const byPlayers = { solo: 0, duo: 0, party: 0 };
+  
+  Object.entries(GAMES_CATALOG).forEach(([category, games]) => {
+    byCategory[category] = games.length;
+  });
+  
+  allGames.forEach(game => {
+    if (!game.players || game.players === 1) {
+      byPlayers.solo++;
+    } else if (game.players === 2) {
+      byPlayers.duo++;
+    } else {
+      byPlayers.party++;
+    }
+  });
+  
+  return { totalGames, byCategory, byPlayers };
+}
+
+// Format games display
+function formatGamesDisplay(games, title, showCommands = true) {
+  if (games.length === 0) {
+    return `**${title}**\nNo games found matching your criteria.`;
+  }
+  
+  let display = `## ${title}\n\n`;
+  
+  for (const game of games) {
+    display += `### ${game.emoji} ${game.name}\n`;
+    display += `${game.description}\n\n`;
+    
+    // Game details
+    const details = [];
+    if (game.players) details.push(`👥 ${game.players} players`);
+    if (game.difficulty) details.push(`🎯 ${game.difficulty}`);
+    if (game.playtime) details.push(`⏱️ ${game.playtime}`);
+    
+    if (details.length > 0) {
+      display += `**Details:** ${details.join(' • ')}\n`;
+    }
+    
+    if (showCommands) {
+      display += `**Play:** \`${game.command}\`\n\n`;
+    } else {
+      display += '\n';
+    }
+  }
+  
+  return display;
+}
+
+// Get games by category
+function getGamesByCategory(category) {
+  if (category === 'all') {
+    return Object.values(GAMES_CATALOG).flat();
+  }
+  
+  const categoryMap = {
+    'solo': 'solo',
+    'multiplayer': ['versus', 'party'],
+    'collaborative': 'collaborative', 
+    'party': 'party',
+    'creative': 'collaborative' // Alias for collaborative
+  };
+  
+  const targetCategories = Array.isArray(categoryMap[category]) ? 
+    categoryMap[category] : [categoryMap[category]];
+  
+  const games = [];
+  for (const cat of targetCategories) {
+    if (GAMES_CATALOG[cat]) {
+      games.push(...GAMES_CATALOG[cat]);
+    }
+  }
+  
+  return games;
+}
+
+// Get games by player count
+function getGamesByPlayers(playerCount) {
+  const allGames = Object.values(GAMES_CATALOG).flat();
+  
+  return allGames.filter(game => {
+    if (!game.players) return playerCount === 1; // Solo games
+    
+    const players = game.players;
+    
+    // Handle ranges like "2-6" or "3+"
+    if (typeof players === 'string') {
+      if (players.includes('-')) {
+        const [min, max] = players.split('-').map(n => parseInt(n));
+        return playerCount >= min && playerCount <= max;
+      } else if (players.includes('+')) {
+        const min = parseInt(players.replace('+', ''));
+        return playerCount >= min;
+      }
+      return parseInt(players) === playerCount;
+    }
+    
+    return players === playerCount;
+  });
+}
+
+// Get mood-based recommendations
+function getMoodRecommendations(mood) {
+  const gameNames = MOOD_RECOMMENDATIONS[mood] || [];
+  const allGames = Object.values(GAMES_CATALOG).flat();
+  
+  return allGames.filter(game => gameNames.includes(game.name));
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { category = 'all', players, mood } = args;
+
+  // Handle mood-based recommendations
+  if (mood) {
+    const games = getMoodRecommendations(mood);
+    const title = `🎮 Games for ${mood.toUpperCase()} mood`;
+    return {
+      display: formatGamesDisplay(games, title)
+    };
+  }
+  
+  // Handle player count filter
+  if (players) {
+    const games = getGamesByPlayers(players);
+    const title = `🎮 Games for ${players} player${players !== 1 ? 's' : ''}`;
+    return {
+      display: formatGamesDisplay(games, title)
+    };
+  }
+  
+  // Handle category filter
+  if (category && category !== 'all') {
+    const games = getGamesByCategory(category);
+    const title = `🎮 ${category.toUpperCase()} Games`;
+    return {
+      display: formatGamesDisplay(games, title)
+    };
+  }
+  
+  // Show full catalog (default)
+  const stats = getGameStats();
+  
+  let display = `# 🎮 /vibe Games Catalog\n\n`;
+  display += `Welcome to the /vibe games arcade! We have **${stats.totalGames} games** across multiple categories.\n\n`;
+  
+  // Quick stats
+  display += `**Quick Browse:**\n`;
+  display += `• 🎯 \`vibe games --category solo\` - ${stats.byCategory.solo} solo games\n`;
+  display += `• ⚔️ \`vibe games --category versus\` - 1v1 competitive games\n`; 
+  display += `• 🎨 \`vibe games --category collaborative\` - Create together\n`;
+  display += `• 🎉 \`vibe games --category party\` - Group fun\n\n`;
+  
+  display += `**By Mood:**\n`;
+  display += `• 🏆 \`vibe games --mood competitive\` - Ready to win\n`;
+  display += `• 🎨 \`vibe games --mood creative\` - Make something cool\n`;
+  display += `• 😌 \`vibe games --mood chill\` - Relaxed fun\n`;
+  display += `• 🧠 \`vibe games --mood brainy\` - Mental challenge\n`;
+  display += `• 👥 \`vibe games --mood social\` - Connect with others\n\n`;
+  
+  display += `**By Players:**\n`;
+  display += `• \`vibe games --players 1\` - Solo adventures\n`;
+  display += `• \`vibe games --players 2\` - Perfect for pairs\n`;  
+  display += `• \`vibe games --players 4\` - Small group games\n\n`;
+  
+  // Highlight featured games
+  display += `## ⭐ Featured Games\n\n`;
+  
+  const featured = [
+    GAMES_CATALOG.collaborative[0], // Drawing
+    GAMES_CATALOG.party[0], // Word Association  
+    GAMES_CATALOG.versus[1], // Chess
+    GAMES_CATALOG.solo[0] // 20 Questions
+  ];
+  
+  for (const game of featured) {
+    display += `**${game.emoji} ${game.name}** - ${game.description}\n`;
+    display += `▸ \`${game.command}\`\n\n`;
+  }
+  
+  display += `💡 **Tip:** Many games work great for icebreakers, team building, or just having fun with friends!\n\n`;
+  display += `Use \`vibe games --category all\` to see the complete catalog with details.`;
+  
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/games.js

@@ -0,0 +1,313 @@
+/**
+ * vibe games — Browse and launch workshop games
+ * 
+ * Discover all available games, get recommendations, and launch games
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { createGamePayload, formatPayload } = require('../protocol');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Import game systems
+const arcade = require('../games/arcade');
+const gamerouter = require('../games/gamerouter');
+
+// Track active game sessions per user
+const activeSessions = new Map();
+
+const definition = {
+  name: 'vibe_games',
+  description: 'Browse and launch workshop games. Discover new games, get recommendations, or launch any game.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'What to do: browse, launch, suggest, help, status',
+        enum: ['browse', 'launch', 'suggest', 'help', 'status', 'quit']
+      },
+      game: {
+        type: 'string',
+        description: 'Game to launch (e.g., hangman, wordchain, drawing)'
+      },
+      category: {
+        type: 'string',
+        description: 'Game category to browse (classic, word, puzzle, action, creative, social)'
+      },
+      difficulty: {
+        type: 'string',
+        description: 'Difficulty preference for suggestions (easy, medium, hard)',
+        enum: ['easy', 'medium', 'hard']
+      },
+      players: {
+        type: 'string',
+        description: 'Player preference for suggestions (solo, multiplayer)',
+        enum: ['solo', 'multiplayer']
+      },
+      command: {
+        type: 'string',
+        description: 'Command to send to active game'
+      }
+    },
+    required: []
+  }
+};
+
+// Get user session
+function getUserSession(handle) {
+  if (!activeSessions.has(handle)) {
+    activeSessions.set(handle, {
+      currentGame: null,
+      gameState: null,
+      arcadeState: arcade.createInitialArcadeState(),
+      lastActivity: new Date().toISOString()
+    });
+  }
+  return activeSessions.get(handle);
+}
+
+// Clear user session
+function clearUserSession(handle) {
+  activeSessions.delete(handle);
+}
+
+// Format game list for display
+function formatGameList(games, title = 'Games') {
+  if (!games || games.length === 0) {
+    return `**${title}**\n*No games found.*`;
+  }
+  
+  let display = `**${title}** (${games.length} games)\n\n`;
+  
+  games.forEach(game => {
+    display += `${game.icon || '🎮'} **${game.name}**\n`;
+    display += `   *${game.description}*\n`;
+    display += `   Players: ${game.players} • Difficulty: ${game.difficulty}\n\n`;
+  });
+  
+  return display;
+}
+
+// Launch a specific game
+function launchGame(session, gameId) {
+  // Check if game exists
+  if (!gamerouter.gameAvailable(gameId)) {
+    const availableGames = gamerouter.getAvailableGames();
+    return { 
+      error: `Game '${gameId}' not found! Available games: ${availableGames.join(', ')}`
+    };
+  }
+  
+  // Create game state
+  const result = gamerouter.createGameState(gameId);
+  if (result.error) {
+    return { error: result.error };
+  }
+  
+  // Update session
+  session.currentGame = gameId;
+  session.gameState = result.gameState;
+  session.lastActivity = new Date().toISOString();
+  
+  // Get display
+  const display = gamerouter.displayGame(gameId, result.gameState);
+  const instructions = gamerouter.getQuickStart(gameId);
+  
+  return {
+    success: true,
+    display: display + '\n\n💡 **Quick Start:** ' + instructions + '\n\n*Use `vibe games --command [action]` to play, or `vibe games --action quit` to exit.*'
+  };
+}
+
+// Handle game command
+function handleGameCommand(session, command) {
+  if (!session.currentGame || !session.gameState) {
+    return { error: 'No active game. Use `vibe games --action launch --game [name]` to start a game.' };
+  }
+  
+  const result = gamerouter.handleGameCommand(session.currentGame, session.gameState, command);
+  if (result.error) {
+    return { error: result.error };
+  }
+  
+  // Update session
+  if (result.gameState) {
+    session.gameState = result.gameState;
+    session.lastActivity = new Date().toISOString();
+  }
+  
+  // Format response
+  let display = '';
+  if (result.display) {
+    display = result.display;
+  } else if (result.gameState) {
+    display = gamerouter.displayGame(session.currentGame, result.gameState);
+  } else {
+    display = 'Command processed.';
+  }
+  
+  return { success: true, display: display };
+}
+
+// Generate game recommendations
+function getRecommendations(difficulty = 'any', players = 'any') {
+  const suggestions = gamerouter.getGameSuggestions(players, difficulty);
+  
+  let display = '🎯 **Game Recommendations**\n\n';
+  
+  if (difficulty !== 'any') {
+    display += `*${difficulty.charAt(0).toUpperCase() + difficulty.slice(1)} difficulty games*\n`;
+  }
+  if (players !== 'any') {
+    display += `*${players.charAt(0).toUpperCase() + players.slice(1)} games*\n`;
+  }
+  
+  display += '\n';
+  
+  const recommendedGames = suggestions.slice(0, 6); // Show top 6 recommendations
+  
+  recommendedGames.forEach(game => {
+    const status = game.available ? '✅' : '🚧';
+    display += `${status} ${game.icon || '🎮'} **${game.name}** (${game.players})\n`;
+    display += `   *${game.description}*\n`;
+    display += `   Launch with: \`vibe games --action launch --game ${game.id}\`\n\n`;
+  });
+  
+  if (suggestions.length > 6) {
+    display += `*... and ${suggestions.length - 6} more games! Use \`vibe games --action browse\` to see all.*\n`;
+  }
+  
+  return display;
+}
+
+// Generate help text
+function generateHelp() {
+  return `🎮 **Workshop Games Help**
+
+**Actions:**
+• \`vibe games --action browse\` - Browse all available games
+• \`vibe games --action browse --category word\` - Browse word games  
+• \`vibe games --action launch --game hangman\` - Launch hangman game
+• \`vibe games --action suggest\` - Get game recommendations
+• \`vibe games --action suggest --difficulty easy --players solo\` - Filtered suggestions
+• \`vibe games --action status\` - See your current game status
+• \`vibe games --action quit\` - Quit current game
+
+**Game Categories:**
+🎲 classic • 📝 word • 🧩 puzzle • ⚡ action • 🎨 creative • 👥 social
+
+**While Playing:**
+• \`vibe games --command [action]\` - Send command to current game
+• Each game has its own commands - check the quick start guide!
+
+**Popular Games:**
+⭕ tic-tac-toe • 🎯 hangman • 🔗 wordchain • 🎨 drawing • ❓ twentyquestions
+
+*Type \`vibe games --action browse\` to see all ${gamerouter.getAvailableGames().length} available games!*`;
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { action = 'browse', game, category, difficulty, players, command } = args;
+  const myHandle = config.getHandle();
+  const session = getUserSession(myHandle);
+
+  try {
+    switch (action) {
+      case 'help':
+        return { display: generateHelp() };
+
+      case 'browse': {
+        if (category) {
+          // Browse specific category using arcade
+          const result = arcade.navigateToCategory(session.arcadeState, category);
+          if (result.error) {
+            return { display: result.error };
+          }
+          session.arcadeState = result.gameState;
+          const display = arcade.formatArcadeDisplay(session.arcadeState);
+          return { display };
+        } else {
+          // Browse all games using arcade
+          session.arcadeState = arcade.createInitialArcadeState();
+          const display = arcade.formatArcadeDisplay(session.arcadeState);
+          return { display };
+        }
+      }
+
+      case 'launch': {
+        if (!game) {
+          return { display: 'Please specify a game to launch. Use `vibe games --action browse` to see available games.' };
+        }
+        return launchGame(session, game);
+      }
+
+      case 'suggest': {
+        const display = getRecommendations(difficulty, players);
+        return { display };
+      }
+
+      case 'status': {
+        if (session.currentGame) {
+          const display = gamerouter.displayGame(session.currentGame, session.gameState);
+          return { 
+            display: `**Current Game:** ${session.currentGame}\n\n${display}\n\n*Use \`vibe games --command [action]\` to play, or \`vibe games --action quit\` to exit.*`
+          };
+        } else {
+          const totalGames = gamerouter.getAvailableGames().length;
+          return { 
+            display: `**No Active Game**\n\n🎮 **${totalGames} games available** in the Workshop\n\nUse \`vibe games --action launch --game [name]\` to start a game\nOr \`vibe games --action browse\` to explore all games` 
+          };
+        }
+      }
+
+      case 'quit': {
+        if (session.currentGame) {
+          const gameName = session.currentGame;
+          session.currentGame = null;
+          session.gameState = null;
+          return { display: `✅ Quit ${gameName}. Use \`vibe games --action browse\` to find another game!` };
+        } else {
+          return { display: 'No active game to quit.' };
+        }
+      }
+
+      default: {
+        // If we have a command and active game, handle it
+        if (command && session.currentGame) {
+          return handleGameCommand(session, command);
+        }
+        
+        // Default to browse if no specific action
+        session.arcadeState = arcade.createInitialArcadeState();
+        const display = arcade.formatArcadeDisplay(session.arcadeState);
+        return { display };
+      }
+    }
+
+  } catch (error) {
+    console.error('[games] Error:', error);
+    return { display: `Error: ${error.message}. Try \`vibe games --action help\` for usage.` };
+  }
+}
+
+// Clean up inactive sessions (called periodically)
+function cleanupInactiveSessions() {
+  const now = Date.now();
+  const TIMEOUT = 30 * 60 * 1000; // 30 minutes
+  
+  for (const [handle, session] of activeSessions.entries()) {
+    const lastActivity = new Date(session.lastActivity).getTime();
+    if (now - lastActivity > TIMEOUT) {
+      activeSessions.delete(handle);
+    }
+  }
+}
+
+// Run cleanup every 10 minutes
+setInterval(cleanupInactiveSessions, 10 * 60 * 1000);
+
+module.exports = { definition, handler };