slashvibe-mcp 0.3.20 → 0.3.21

package/games/wordassociation.js

@@ -0,0 +1,247 @@
+/**
+ * Word Association game implementation for /vibe
+ * Players take turns saying words that associate with the previous word
+ * Build creative chains of connected ideas!
+ */
+
+// Simple word validation
+function isValidWord(word) {
+  // Basic checks: alphabetic, reasonable length, not too short
+  if (!/^[a-zA-Z\-']+$/.test(word)) return false; // Allow hyphens and apostrophes
+  if (word.length < 2) return false;
+  if (word.length > 30) return false;
+  
+  // Allow single meaningful words
+  if (word.length === 1) {
+    return ['a', 'i'].includes(word.toLowerCase());
+  }
+  
+  return true;
+}
+
+// Create initial word association state
+function createInitialWordAssociationState() {
+  return {
+    words: [],
+    players: [],
+    currentPlayer: null,
+    moves: 0,
+    gameOver: false,
+    winner: null,
+    lastWord: null,
+    usedWords: new Set(), // Track words to prevent exact repeats
+    playerTurnIndex: 0,
+    maxWords: 30, // End game after 30 words for now
+    associations: [], // Store word -> word pairs for fun stats
+    startedAt: new Date().toISOString()
+  };
+}
+
+// Add player to game
+function addPlayer(gameState, playerHandle) {
+  if (gameState.players.includes(playerHandle)) {
+    return { error: 'Player already in the game' };
+  }
+
+  if (gameState.players.length >= 6) {
+    return { error: 'Game is full (max 6 players)' };
+  }
+
+  const newPlayers = [...gameState.players, playerHandle];
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      players: newPlayers,
+      currentPlayer: gameState.currentPlayer || playerHandle // First player starts
+    }
+  };
+}
+
+// Make a word association move
+function makeMove(gameState, word, playerHandle) {
+  const { words, players, currentPlayer, moves, usedWords, lastWord, maxWords } = gameState;
+  
+  // Normalize word
+  const normalizedWord = word.toLowerCase().trim().replace(/['"]/g, '');
+  
+  // Validate basic word format
+  if (!isValidWord(normalizedWord)) {
+    return { error: 'Invalid word format. Use only letters (2-30 characters).' };
+  }
+  
+  // Check if it's the right player's turn (if multiplayer)
+  if (players.length > 1 && currentPlayer !== playerHandle) {
+    return { error: `Not your turn! Waiting for @${currentPlayer}` };
+  }
+  
+  // Check if word was already used (allow some flexibility)
+  if (usedWords.has(normalizedWord)) {
+    return { error: 'Word already used! Try a different word.' };
+  }
+  
+  // Check if it's the same word as last word
+  if (lastWord && normalizedWord === lastWord.toLowerCase()) {
+    return { error: 'Cannot repeat the same word immediately!' };
+  }
+  
+  // Valid move - update game state
+  const newWords = [...words, { word: normalizedWord, player: playerHandle, timestamp: new Date().toISOString() }];
+  const newUsedWords = new Set([...usedWords, normalizedWord]);
+  const newAssociations = lastWord ? [...gameState.associations, `${lastWord} → ${normalizedWord}`] : gameState.associations;
+  
+  // Determine next player
+  let nextPlayerIndex = gameState.playerTurnIndex;
+  let nextPlayer = currentPlayer;
+  
+  if (players.length > 1) {
+    nextPlayerIndex = (gameState.playerTurnIndex + 1) % players.length;
+    nextPlayer = players[nextPlayerIndex];
+  }
+  
+  // Check if game should end
+  const shouldEnd = moves + 1 >= maxWords;
+  
+  const newGameState = {
+    ...gameState,
+    words: newWords,
+    currentPlayer: shouldEnd ? null : nextPlayer,
+    playerTurnIndex: nextPlayerIndex,
+    moves: moves + 1,
+    gameOver: shouldEnd,
+    winner: shouldEnd ? 'everyone' : null,
+    lastWord: normalizedWord,
+    usedWords: newUsedWords,
+    associations: newAssociations
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Format word association for display
+function formatWordAssociationDisplay(gameState) {
+  const { words, players, currentPlayer, moves, gameOver, maxWords, associations } = gameState;
+  
+  let display = `🧠 **Word Association** (${moves}/${maxWords} words)\n\n`;
+  
+  if (gameOver) {
+    display += '🎉 **Game Complete!** What a creative journey!\n\n';
+  }
+  
+  if (words.length === 0) {
+    if (players.length === 0) {
+      display += '**Start with any word!**\n\n';
+      display += 'Word association is about connecting ideas. Each new word should relate to the previous one.\n';
+    } else {
+      display += `**@${currentPlayer}, start us off with any word!**\n\n`;
+    }
+  } else {
+    // Show the association chain (last 8 words to keep it readable)
+    const recentWords = words.slice(-8);
+    const wordChain = recentWords.map(w => {
+      const capitalizedWord = w.word.charAt(0).toUpperCase() + w.word.slice(1);
+      return `**${capitalizedWord}** (@${w.player})`;
+    }).join(' → ');
+    
+    display += '**Chain:** ' + wordChain;
+    
+    if (words.length > 8) {
+      display += ` (showing last 8 of ${words.length})`;
+    }
+    
+    display += '\n\n';
+    
+    if (!gameOver) {
+      const lastWordEntry = words[words.length - 1];
+      const lastWord = lastWordEntry.word;
+      display += `**"${lastWord.charAt(0).toUpperCase() + lastWord.slice(1)}" makes you think of...**\n\n`;
+      
+      if (players.length > 1) {
+        display += `Turn: **@${currentPlayer}**`;
+      } else {
+        display += '**Your turn!** What word comes to mind?';
+      }
+    }
+  }
+  
+  // Show players if multiplayer
+  if (players.length > 1) {
+    display += `\n\n**Players (${players.length}):** ${players.map(p => `@${p}`).join(', ')}`;
+  }
+  
+  // Show some fun stats at the end
+  if (gameOver && associations.length > 0) {
+    display += '\n\n**Creative Journey:**\n';
+    // Show the full chain condensed
+    const fullChain = words.map(w => w.word.charAt(0).toUpperCase() + w.word.slice(1)).join(' → ');
+    display += fullChain;
+  }
+  
+  return display;
+}
+
+// Get game stats for fun
+function getGameStats(gameState) {
+  const { words, players, associations } = gameState;
+  
+  if (words.length === 0) return null;
+  
+  // Player contribution stats
+  const contributions = {};
+  words.forEach(w => {
+    contributions[w.player] = (contributions[w.player] || 0) + 1;
+  });
+  
+  return {
+    totalWords: words.length,
+    contributors: Object.keys(contributions).length,
+    contributions,
+    longestWord: Math.max(...words.map(w => w.word.length)),
+    shortestWord: Math.min(...words.map(w => w.word.length)),
+    uniqueWords: new Set(words.map(w => w.word)).size
+  };
+}
+
+// Check for interesting patterns or themes
+function findThemes(gameState) {
+  const { words } = gameState;
+  
+  if (words.length < 3) return [];
+  
+  const themes = [];
+  const wordList = words.map(w => w.word.toLowerCase());
+  
+  // Look for color words
+  const colors = ['red', 'blue', 'green', 'yellow', 'orange', 'purple', 'pink', 'black', 'white', 'brown', 'gray', 'grey'];
+  const colorWords = wordList.filter(w => colors.includes(w));
+  if (colorWords.length >= 2) {
+    themes.push(`🌈 Colors: ${colorWords.join(', ')}`);
+  }
+  
+  // Look for animal words
+  const animals = ['cat', 'dog', 'bird', 'fish', 'mouse', 'lion', 'tiger', 'bear', 'wolf', 'fox', 'rabbit', 'horse', 'cow', 'pig', 'sheep'];
+  const animalWords = wordList.filter(w => animals.some(animal => w.includes(animal) || animal.includes(w)));
+  if (animalWords.length >= 2) {
+    themes.push(`🐾 Animals: ${animalWords.join(', ')}`);
+  }
+  
+  // Look for nature words
+  const nature = ['tree', 'flower', 'water', 'sun', 'moon', 'star', 'cloud', 'rain', 'snow', 'mountain', 'ocean', 'forest'];
+  const natureWords = wordList.filter(w => nature.some(n => w.includes(n) || n.includes(w)));
+  if (natureWords.length >= 2) {
+    themes.push(`🌿 Nature: ${natureWords.join(', ')}`);
+  }
+  
+  return themes;
+}
+
+module.exports = {
+  createInitialWordAssociationState,
+  addPlayer,
+  makeMove,
+  formatWordAssociationDisplay,
+  isValidWord,
+  getGameStats,
+  findThemes
+};

package/games/wordchain.js

@@ -0,0 +1,135 @@
+/**
+ * Word Chain game implementation for /vibe
+ * Players take turns saying words that start with the last letter of the previous word
+ */
+
+// Simple word validation - checks if it's a reasonable English word
+// In a full implementation, this could use a proper dictionary API
+function isValidWord(word) {
+  // Basic checks: alphabetic, reasonable length, not too short
+  if (!/^[a-zA-Z]+$/.test(word)) return false;
+  if (word.length < 2) return false;
+  if (word.length > 20) return false;
+  
+  // Some very basic filtering of common valid words vs nonsense
+  // This is a simplified check - a real game would use a dictionary
+  const commonPrefixes = ['th', 'he', 'in', 'er', 'an', 're', 'ed', 'nd', 'ou', 'ea', 'ti', 'to', 'it', 'st', 'io', 'le', 'is', 'on', 'ur', 'ar', 'nt', 'al'];
+  const commonSuffixes = ['ed', 'er', 'ing', 'ly', 'est', 'ion', 'tion', 'sion', 'ness', 'ment', 'able', 'ible'];
+  
+  const lowerWord = word.toLowerCase();
+  
+  // Allow single letters for now (like 'a', 'i')
+  if (word.length === 1) {
+    return ['a', 'i'].includes(lowerWord);
+  }
+  
+  // Check for common patterns that suggest it's a real word
+  const hasCommonPrefix = commonPrefixes.some(prefix => lowerWord.startsWith(prefix));
+  const hasCommonSuffix = commonSuffixes.some(suffix => lowerWord.endsWith(suffix));
+  
+  // Very permissive check - if it looks word-like, allow it
+  // Real implementation would check against dictionary
+  return hasCommonPrefix || hasCommonSuffix || lowerWord.length >= 3;
+}
+
+// Create initial word chain state
+function createInitialWordChainState() {
+  return {
+    words: [],
+    currentPlayer: 'player1', // player1 starts (the person who initiated the game)
+    moves: 0,
+    gameOver: false,
+    winner: null,
+    lastLetter: null,
+    usedWords: new Set() // Track words to prevent repeats
+  };
+}
+
+// Make a word chain move
+function makeMove(gameState, word, isPlayer1Move) {
+  const { words, currentPlayer, moves, usedWords, lastLetter } = gameState;
+  
+  // Normalize word
+  const normalizedWord = word.toLowerCase().trim();
+  
+  // Validate basic word format
+  if (!isValidWord(normalizedWord)) {
+    return { error: 'Invalid word format. Use only letters, 2-20 characters.' };
+  }
+  
+  // Check if it's the right player's turn
+  const expectedPlayer = currentPlayer === 'player1' ? true : false;
+  if (isPlayer1Move !== expectedPlayer) {
+    return { error: 'Not your turn!' };
+  }
+  
+  // Check if word was already used
+  if (usedWords.has(normalizedWord)) {
+    return { error: 'Word already used! Try a different word.' };
+  }
+  
+  // Check if word starts with the required letter
+  if (lastLetter && normalizedWord[0] !== lastLetter) {
+    return { error: `Word must start with "${lastLetter.toUpperCase()}"` };
+  }
+  
+  // Valid move - update game state
+  const newWords = [...words, normalizedWord];
+  const newUsedWords = new Set([...usedWords, normalizedWord]);
+  const newLastLetter = normalizedWord[normalizedWord.length - 1];
+  const newCurrentPlayer = currentPlayer === 'player1' ? 'player2' : 'player1';
+  
+  const newGameState = {
+    words: newWords,
+    currentPlayer: newCurrentPlayer,
+    moves: moves + 1,
+    gameOver: false,
+    winner: null,
+    lastLetter: newLastLetter,
+    usedWords: newUsedWords,
+    lastWord: normalizedWord
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Format word chain for display
+function formatWordChainDisplay(gameState) {
+  const { words, currentPlayer, moves, lastLetter, lastWord } = gameState;
+  
+  let display = `🔗 **Word Chain** (${moves} words)\n\n`;
+  
+  if (words.length === 0) {
+    display += '**Start the chain with any word!**\n\n';
+    display += 'Next: **Player 1**';
+  } else {
+    // Show the chain
+    display += '**Chain:** ' + words.map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' → ') + '\n\n';
+    
+    if (lastLetter) {
+      display += `**Next word must start with: "${lastLetter.toUpperCase()}"**\n\n`;
+    }
+    
+    display += `Turn: **${currentPlayer === 'player1' ? 'Player 1' : 'Player 2'}**`;
+    
+    if (lastWord) {
+      display += `\nLast word: "${lastWord.charAt(0).toUpperCase() + lastWord.slice(1)}"`;
+    }
+  }
+  
+  return display;
+}
+
+// Check if a letter is considered "difficult" (fewer common words start with it)
+function isDifficultLetter(letter) {
+  const difficultLetters = ['x', 'z', 'q', 'j', 'v'];
+  return difficultLetters.includes(letter.toLowerCase());
+}
+
+module.exports = {
+  createInitialWordChainState,
+  makeMove,
+  formatWordChainDisplay,
+  isValidWord,
+  isDifficultLetter
+};