slashvibe-mcp 0.3.20 → 0.3.21

package/games/colorguess.js

@@ -0,0 +1,343 @@
+/**
+ * Color Guessing Game implementation for /vibe
+ * One player thinks of a color, others try to guess it with helpful hints!
+ * Simple, social, and fun for quick breaks.
+ */
+
+// Predefined color list with emojis for fun display
+const COLORS = {
+  // Basic colors
+  'red': '🔴',
+  'blue': '🔵', 
+  'green': '🟢',
+  'yellow': '🟡',
+  'purple': '🟣',
+  'orange': '🟠',
+  'black': '⚫',
+  'white': '⚪',
+  'brown': '🟤',
+  'pink': '🩷',
+  'gray': '⚫', // Using black circle for gray
+  'grey': '⚫',
+  
+  // Fun colors
+  'lime': '🟢',
+  'cyan': '🔵',
+  'magenta': '🟣',
+  'navy': '🔵',
+  'maroon': '🔴',
+  'olive': '🟢',
+  'teal': '🔵',
+  'silver': '⚪',
+  'gold': '🟡',
+  'coral': '🟠',
+  'salmon': '🟠',
+  'turquoise': '🔵',
+  'indigo': '🟣',
+  'violet': '🟣',
+  'crimson': '🔴',
+  'azure': '🔵',
+  'beige': '🟤',
+  'ivory': '⚪',
+  'khaki': '🟤',
+  'lavender': '🟣',
+  'mint': '🟢',
+  'peach': '🟠',
+  'rose': '🩷',
+  'rust': '🟠',
+  'sage': '🟢',
+  'tan': '🟤'
+};
+
+// Get list of all valid color names
+function getValidColors() {
+  return Object.keys(COLORS);
+}
+
+// Get emoji for a color
+function getColorEmoji(color) {
+  return COLORS[color.toLowerCase()] || '🎨';
+}
+
+// Create initial color guessing game state
+function createInitialColorGuessState() {
+  return {
+    gameId: Date.now().toString(),
+    phase: 'setup', // 'setup', 'guessing', 'complete'
+    host: null, // Player who chose the color
+    secretColor: null,
+    players: [],
+    guesses: [],
+    hints: [],
+    maxPlayers: 6,
+    maxGuesses: 10,
+    gameOver: false,
+    winner: null,
+    createdAt: new Date().toISOString(),
+    lastActivity: new Date().toISOString()
+  };
+}
+
+// Add player to the game
+function addPlayer(gameState, playerHandle) {
+  const { players, maxPlayers, phase } = gameState;
+  
+  if (players.includes(playerHandle)) {
+    return { error: 'You are already in this game!' };
+  }
+  
+  if (players.length >= maxPlayers) {
+    return { error: `Game is full (max ${maxPlayers} players)` };
+  }
+  
+  if (phase !== 'setup') {
+    return { error: 'Game is already in progress! Wait for the next round.' };
+  }
+  
+  const newPlayers = [...players, playerHandle];
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      players: newPlayers,
+      lastActivity: new Date().toISOString()
+    }
+  };
+}
+
+// Set the secret color (only host can do this)
+function setSecretColor(gameState, color, playerHandle) {
+  const { phase, players } = gameState;
+  
+  if (players.length === 0 || players[0] !== playerHandle) {
+    return { error: 'Only the host can set the secret color!' };
+  }
+  
+  if (phase !== 'setup') {
+    return { error: 'Game has already started!' };
+  }
+  
+  const normalizedColor = color.toLowerCase().trim();
+  if (!COLORS[normalizedColor]) {
+    const validColors = getValidColors();
+    const suggestions = validColors.filter(c => c.startsWith(normalizedColor.slice(0, 2))).slice(0, 3);
+    return { 
+      error: `"${color}" is not a valid color. Try: ${suggestions.length > 0 ? suggestions.join(', ') : 'red, blue, green, yellow, purple, orange, pink, etc.'}`
+    };
+  }
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      secretColor: normalizedColor,
+      host: playerHandle,
+      phase: 'guessing',
+      lastActivity: new Date().toISOString()
+    }
+  };
+}
+
+// Make a guess
+function makeGuess(gameState, guess, playerHandle) {
+  const { phase, players, host, secretColor, guesses, maxGuesses, gameOver } = gameState;
+  
+  if (!players.includes(playerHandle)) {
+    return { error: 'You need to join the game first!' };
+  }
+  
+  if (playerHandle === host) {
+    return { error: 'The host cannot guess their own color!' };
+  }
+  
+  if (phase !== 'guessing') {
+    return { error: 'Game is not in guessing phase!' };
+  }
+  
+  if (gameOver) {
+    return { error: 'Game is already over!' };
+  }
+  
+  if (guesses.length >= maxGuesses) {
+    return { error: 'Maximum guesses reached!' };
+  }
+  
+  const normalizedGuess = guess.toLowerCase().trim();
+  
+  // Check if already guessed
+  if (guesses.some(g => g.color === normalizedGuess)) {
+    return { error: `"${guess}" has already been guessed!` };
+  }
+  
+  if (!COLORS[normalizedGuess]) {
+    return { error: `"${guess}" is not a valid color. Try common colors like red, blue, green, etc.` };
+  }
+  
+  const isCorrect = normalizedGuess === secretColor;
+  const newGuess = {
+    player: playerHandle,
+    color: normalizedGuess,
+    correct: isCorrect,
+    timestamp: new Date().toISOString(),
+    guessNumber: guesses.length + 1
+  };
+  
+  const newGuesses = [...guesses, newGuess];
+  const isGameOver = isCorrect || newGuesses.length >= maxGuesses;
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      guesses: newGuesses,
+      gameOver: isGameOver,
+      winner: isCorrect ? playerHandle : null,
+      phase: isGameOver ? 'complete' : 'guessing',
+      lastActivity: new Date().toISOString()
+    }
+  };
+}
+
+// Add a hint (only host can do this)
+function addHint(gameState, hint, playerHandle) {
+  const { host, phase, hints, gameOver } = gameState;
+  
+  if (playerHandle !== host) {
+    return { error: 'Only the host can give hints!' };
+  }
+  
+  if (phase !== 'guessing' || gameOver) {
+    return { error: 'Cannot give hints right now!' };
+  }
+  
+  if (hint.trim().length === 0) {
+    return { error: 'Hint cannot be empty!' };
+  }
+  
+  // Don't allow hints that contain the color name
+  const secretColor = gameState.secretColor.toLowerCase();
+  if (hint.toLowerCase().includes(secretColor)) {
+    return { error: 'Hint cannot contain the color name!' };
+  }
+  
+  const newHint = {
+    text: hint.trim(),
+    timestamp: new Date().toISOString(),
+    hintNumber: hints.length + 1
+  };
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      hints: [...hints, newHint],
+      lastActivity: new Date().toISOString()
+    }
+  };
+}
+
+// Format the game display
+function formatColorGuessDisplay(gameState) {
+  const { phase, host, players, guesses, hints, secretColor, winner, gameOver, maxGuesses } = gameState;
+  
+  let display = `🎨 **Color Guessing Game**\n\n`;
+  
+  if (phase === 'setup') {
+    display += '**Setting up...**\n\n';
+    
+    if (players.length === 0) {
+      display += 'Waiting for players to join!\n';
+    } else {
+      display += `**Host:** @${host || players[0]}\n`;
+      display += `**Players:** ${players.map(p => `@${p}`).join(', ')}\n\n`;
+      
+      if (!secretColor) {
+        display += `Waiting for @${players[0]} to choose a secret color...\n`;
+      }
+    }
+    
+  } else if (phase === 'guessing') {
+    display += `**Host:** @${host} ${getColorEmoji('rainbow')}\n`;
+    display += `**Guessers:** ${players.filter(p => p !== host).map(p => `@${p}`).join(', ')}\n\n`;
+    
+    // Show hints
+    if (hints.length > 0) {
+      display += '**Hints:**\n';
+      hints.forEach((hint, i) => {
+        display += `${i + 1}. ${hint.text}\n`;
+      });
+      display += '\n';
+    }
+    
+    // Show previous guesses
+    if (guesses.length > 0) {
+      display += '**Previous guesses:**\n';
+      guesses.forEach(guess => {
+        display += `${getColorEmoji(guess.color)} ${guess.color} by @${guess.player}${guess.correct ? ' ✅' : ' ❌'}\n`;
+      });
+      display += '\n';
+    }
+    
+    display += `**Guesses remaining:** ${maxGuesses - guesses.length}\n`;
+    
+  } else if (phase === 'complete') {
+    display += '**Game Complete!**\n\n';
+    display += `**Secret color was:** ${getColorEmoji(secretColor)} ${secretColor}\n\n`;
+    
+    if (winner) {
+      display += `🎉 **Winner:** @${winner}!\n\n`;
+    } else {
+      display += `😅 **No one guessed it!** Better luck next time.\n\n`;
+    }
+    
+    // Show all guesses
+    if (guesses.length > 0) {
+      display += '**All guesses:**\n';
+      guesses.forEach(guess => {
+        display += `${getColorEmoji(guess.color)} ${guess.color} by @${guess.player}${guess.correct ? ' ✅' : ' ❌'}\n`;
+      });
+    }
+  }
+  
+  return display;
+}
+
+// Get game statistics
+function getGameStats(gameState) {
+  const { guesses, hints, players, host } = gameState;
+  
+  const playerGuesses = {};
+  guesses.forEach(guess => {
+    playerGuesses[guess.player] = (playerGuesses[guess.player] || 0) + 1;
+  });
+  
+  return {
+    totalGuesses: guesses.length,
+    totalHints: hints.length,
+    totalPlayers: players.length,
+    playerGuesses,
+    mostActiveGuesser: Object.entries(playerGuesses).sort(([,a], [,b]) => b - a)[0]
+  };
+}
+
+// Get color suggestions based on partial input
+function getSuggestions(partial) {
+  const colors = getValidColors();
+  const matches = colors.filter(color => color.startsWith(partial.toLowerCase()));
+  return matches.slice(0, 5); // Return top 5 matches
+}
+
+module.exports = {
+  createInitialColorGuessState,
+  addPlayer,
+  setSecretColor,
+  makeGuess,
+  addHint,
+  formatColorGuessDisplay,
+  getGameStats,
+  getSuggestions,
+  getValidColors,
+  getColorEmoji,
+  COLORS
+};

package/games/crossword-words.js

@@ -0,0 +1,171 @@
+/**
+ * Word banks for /vibe crossword puzzles
+ * Themed collections for daily puzzles
+ */
+
+// Coding/programming theme
+const codingWords = [
+  { answer: 'DEBUG', clue: 'Find and fix bugs' },
+  { answer: 'LOOP', clue: 'Repeat until done' },
+  { answer: 'CODE', clue: 'Write programs' },
+  { answer: 'API', clue: 'Application interface' },
+  { answer: 'GIT', clue: 'Version control system' },
+  { answer: 'NPM', clue: 'Node package manager' },
+  { answer: 'RUST', clue: 'Memory-safe language' },
+  { answer: 'BASH', clue: 'Unix shell' },
+  { answer: 'JSON', clue: 'Data interchange format' },
+  { answer: 'TYPE', clue: 'Data classification' },
+  { answer: 'FUNC', clue: 'Reusable code block' },
+  { answer: 'VOID', clue: 'Returns nothing' },
+  { answer: 'NULL', clue: 'No value' },
+  { answer: 'TRUE', clue: 'Boolean positive' },
+  { answer: 'PUSH', clue: 'Add to array end' },
+  { answer: 'POP', clue: 'Remove from array' },
+  { answer: 'MAP', clue: 'Transform each item' },
+  { answer: 'SORT', clue: 'Arrange in order' },
+  { answer: 'GREP', clue: 'Search text patterns' },
+  { answer: 'LINT', clue: 'Check code style' }
+];
+
+// /vibe and AI theme
+const vibeWords = [
+  { answer: 'VIBE', clue: 'Social layer for Claude Code' },
+  { answer: 'DM', clue: 'Direct message' },
+  { answer: 'AGENT', clue: 'AI that takes action' },
+  { answer: 'MCP', clue: 'Model context protocol' },
+  { answer: 'TOOL', clue: 'Agent capability' },
+  { answer: 'PING', clue: 'Quick hello' },
+  { answer: 'EDEN', clue: 'Spirit training platform' },
+  { answer: 'BOT', clue: 'Automated program' },
+  { answer: 'CHAT', clue: 'Conversation' },
+  { answer: 'LLM', clue: 'Large language model' },
+  { answer: 'AI', clue: 'Artificial intelligence' },
+  { answer: 'SHIP', clue: 'Deploy to production' },
+  { answer: 'BUILD', clue: 'Compile the project' },
+  { answer: 'PROMPT', clue: 'Input to AI' },
+  { answer: 'TOKEN', clue: 'LLM input unit' },
+  { answer: 'CONTEXT', clue: 'Conversation history' }
+];
+
+// Tech culture theme
+const techWords = [
+  { answer: 'CLOUD', clue: 'AWS, Azure, GCP' },
+  { answer: 'SAAS', clue: 'Software as a service' },
+  { answer: 'SCALE', clue: 'Handle more load' },
+  { answer: 'DEPLOY', clue: 'Release to users' },
+  { answer: 'TEST', clue: 'Verify it works' },
+  { answer: 'PROD', clue: 'Production environment' },
+  { answer: 'DEV', clue: 'Development mode' },
+  { answer: 'OPS', clue: 'Operations team' },
+  { answer: 'LOG', clue: 'System record' },
+  { answer: 'CACHE', clue: 'Store for speed' },
+  { answer: 'QUEUE', clue: 'Task backlog' },
+  { answer: 'ASYNC', clue: 'Non-blocking' },
+  { answer: 'SYNC', clue: 'Same time' },
+  { answer: 'PORT', clue: 'Network endpoint' },
+  { answer: 'HOST', clue: 'Server address' },
+  { answer: 'PING', clue: 'Check if alive' },
+  { answer: 'HASH', clue: 'Unique fingerprint' },
+  { answer: 'KEY', clue: 'Access credential' },
+  { answer: 'ENV', clue: 'Environment variable' },
+  { answer: 'CLI', clue: 'Command line interface' }
+];
+
+// General/fun words
+const generalWords = [
+  { answer: 'BRAIN', clue: 'Thinking organ' },
+  { answer: 'SPARK', clue: 'Moment of inspiration' },
+  { answer: 'FLOW', clue: 'In the zone' },
+  { answer: 'FOCUS', clue: 'Concentrated attention' },
+  { answer: 'HACK', clue: 'Clever solution' },
+  { answer: 'SHIP', clue: 'Get it done' },
+  { answer: 'PLAY', clue: 'Have fun' },
+  { answer: 'LEARN', clue: 'Gain knowledge' },
+  { answer: 'CREATE', clue: 'Make something new' },
+  { answer: 'SHARE', clue: 'Give to others' },
+  { answer: 'HELP', clue: 'Assist someone' },
+  { answer: 'WIN', clue: 'Succeed' },
+  { answer: 'START', clue: 'Begin' },
+  { answer: 'END', clue: 'Finish' },
+  { answer: 'NEW', clue: 'Fresh' },
+  { answer: 'OPEN', clue: 'Accessible' },
+  { answer: 'FREE', clue: 'No cost' },
+  { answer: 'FAST', clue: 'Quick' },
+  { answer: 'GOOD', clue: 'Quality' },
+  { answer: 'BEST', clue: 'Top tier' }
+];
+
+// Combine all themes for daily variety
+const allWords = [...codingWords, ...vibeWords, ...techWords, ...generalWords];
+
+/**
+ * Get words for a specific theme
+ */
+function getWordsByTheme(theme) {
+  switch (theme) {
+    case 'coding': return codingWords;
+    case 'vibe': return vibeWords;
+    case 'tech': return techWords;
+    case 'general': return generalWords;
+    case 'all':
+    default:
+      return allWords;
+  }
+}
+
+/**
+ * Seeded random number generator for consistent daily puzzles
+ */
+function seededRandom(seed) {
+  let state = seed;
+  return function() {
+    state = (state * 1103515245 + 12345) & 0x7fffffff;
+    return state / 0x7fffffff;
+  };
+}
+
+/**
+ * Get a subset of words for a puzzle using seeded randomness
+ * @param {string} dateStr - Date string like "2026-01-09"
+ * @param {number} count - Number of words to select
+ * @param {string} theme - Theme to use
+ */
+function getWordsForDate(dateStr, count = 6, theme = 'all') {
+  const words = getWordsByTheme(theme);
+
+  // Create seed from date
+  const seed = dateStr.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0);
+  const random = seededRandom(seed);
+
+  // Shuffle using Fisher-Yates with seeded random
+  const shuffled = [...words];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+
+  // Filter to words that fit a 5x5 grid (2-5 letters)
+  const fittingWords = shuffled.filter(w => w.answer.length >= 2 && w.answer.length <= 5);
+
+  return fittingWords.slice(0, count);
+}
+
+/**
+ * Get today's date string in UTC
+ */
+function getTodayDateStr() {
+  const now = new Date();
+  return now.toISOString().split('T')[0];
+}
+
+module.exports = {
+  codingWords,
+  vibeWords,
+  techWords,
+  generalWords,
+  allWords,
+  getWordsByTheme,
+  getWordsForDate,
+  getTodayDateStr,
+  seededRandom
+};