slashvibe-mcp 0.3.21 → 0.3.22

package/games/wordassociation.js

@@ -1,247 +0,0 @@
-/**
- * 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

@@ -1,135 +0,0 @@
-/**
- * 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
-};