slashvibe-mcp 0.3.20 → 0.3.21

package/games/twentyquestions.js

@@ -0,0 +1,286 @@
+/**
+ * 20 Questions game implementation for /vibe
+ * One player thinks of something, the other tries to guess it in 20 yes/no questions
+ */
+
+// Categories and example items for random selection
+const CATEGORIES = {
+  animals: [
+    'elephant', 'dolphin', 'penguin', 'tiger', 'butterfly', 'octopus', 'kangaroo',
+    'giraffe', 'owl', 'shark', 'panda', 'wolf', 'eagle', 'whale', 'lion',
+    'monkey', 'bear', 'rabbit', 'snake', 'turtle', 'fox', 'deer', 'bat'
+  ],
+  objects: [
+    'smartphone', 'guitar', 'bicycle', 'telescope', 'clock', 'umbrella', 'camera',
+    'mirror', 'keyboard', 'lamp', 'backpack', 'compass', 'hammer', 'scissors',
+    'calculator', 'headphones', 'pencil', 'book', 'chair', 'door', 'window', 'table'
+  ],
+  food: [
+    'pizza', 'chocolate', 'apple', 'sushi', 'ice cream', 'hamburger', 'pasta',
+    'banana', 'cheese', 'bread', 'cookie', 'sandwich', 'orange', 'cake',
+    'popcorn', 'honey', 'soup', 'salad', 'coffee', 'tea', 'yogurt', 'rice'
+  ],
+  places: [
+    'library', 'beach', 'mountain', 'forest', 'castle', 'hospital', 'school',
+    'museum', 'theater', 'restaurant', 'park', 'bridge', 'lighthouse', 'cave',
+    'waterfall', 'desert', 'island', 'city', 'village', 'garden', 'zoo', 'airport'
+  ],
+  activities: [
+    'swimming', 'reading', 'dancing', 'cooking', 'painting', 'singing', 'running',
+    'climbing', 'writing', 'fishing', 'gardening', 'photography', 'camping',
+    'hiking', 'surfing', 'skiing', 'cycling', 'shopping', 'traveling', 'studying'
+  ]
+};
+
+// Get random item from a category or all categories
+function getRandomItem(category = null) {
+  if (category && CATEGORIES[category]) {
+    const items = CATEGORIES[category];
+    return {
+      item: items[Math.floor(Math.random() * items.length)],
+      category: category
+    };
+  } else {
+    // Random from all categories
+    const allCategories = Object.keys(CATEGORIES);
+    const randomCategory = allCategories[Math.floor(Math.random() * allCategories.length)];
+    return getRandomItem(randomCategory);
+  }
+}
+
+// Create initial 20 questions state
+function createInitialTwentyQuestionsState(mode = 'guess', customItem = null, category = null) {
+  const randomSelection = customItem ? 
+    { item: customItem.toLowerCase(), category: 'custom' } : 
+    getRandomItem(category);
+    
+  return {
+    mode: mode, // 'guess' = player guesses AI's item, 'think' = AI guesses player's item
+    item: randomSelection.item,
+    category: randomSelection.category,
+    questions: [],
+    questionsLeft: 20,
+    gameOver: false,
+    won: false,
+    currentQuestion: null,
+    moves: 0,
+    guesses: [] // Track actual guesses (not just questions)
+  };
+}
+
+// Process a question (for 'guess' mode where player asks questions)
+function askQuestion(gameState, question) {
+  const { item, questions, questionsLeft, gameOver, moves } = gameState;
+  
+  if (gameOver) {
+    return { error: 'Game is over! Start a new game to play again.' };
+  }
+  
+  if (questionsLeft <= 0) {
+    return { error: 'No questions left! Make your final guess.' };
+  }
+  
+  // Normalize question
+  const normalizedQuestion = question.toLowerCase().trim();
+  
+  // Check if it's a guess rather than a yes/no question
+  if (normalizedQuestion.startsWith('is it ')) {
+    const guess = normalizedQuestion.substring(6);
+    return processGuess(gameState, guess);
+  }
+  
+  // Simple AI to answer yes/no questions
+  const answer = answerQuestion(normalizedQuestion, item, gameState.category);
+  
+  const newQuestions = [...questions, { question, answer, questionNumber: moves + 1 }];
+  const newQuestionsLeft = questionsLeft - 1;
+  const newMoves = moves + 1;
+  
+  const newGameState = {
+    ...gameState,
+    questions: newQuestions,
+    questionsLeft: newQuestionsLeft,
+    moves: newMoves,
+    currentQuestion: { question, answer }
+  };
+  
+  // Check if no questions left
+  if (newQuestionsLeft === 0) {
+    return {
+      success: true,
+      gameState: {
+        ...newGameState,
+        message: `That's all 20 questions! What's your final guess?`
+      }
+    };
+  }
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Process a final guess
+function processGuess(gameState, guess) {
+  const { item, guesses, gameOver } = gameState;
+  
+  if (gameOver) {
+    return { error: 'Game is already over!' };
+  }
+  
+  const normalizedGuess = guess.toLowerCase().trim();
+  const normalizedItem = item.toLowerCase().trim();
+  
+  // Check for exact match or close match
+  const isCorrect = normalizedGuess === normalizedItem || 
+                   normalizedItem.includes(normalizedGuess) ||
+                   normalizedGuess.includes(normalizedItem);
+  
+  const newGuesses = [...guesses, { guess: normalizedGuess, correct: isCorrect }];
+  
+  const newGameState = {
+    ...gameState,
+    guesses: newGuesses,
+    gameOver: true,
+    won: isCorrect,
+    finalGuess: normalizedGuess
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Simple AI to answer yes/no questions about an item
+function answerQuestion(question, item, category) {
+  const q = question.toLowerCase();
+  const itemLower = item.toLowerCase();
+  
+  // Size-related questions
+  if (q.includes('big') || q.includes('large')) {
+    const bigThings = ['elephant', 'whale', 'giraffe', 'mountain', 'castle', 'tree', 'building', 'car', 'house'];
+    return bigThings.some(thing => itemLower.includes(thing) || thing.includes(itemLower)) ? 'yes' : 'no';
+  }
+  
+  if (q.includes('small') || q.includes('tiny')) {
+    const smallThings = ['butterfly', 'mouse', 'ant', 'coin', 'key', 'pencil', 'ring', 'watch'];
+    return smallThings.some(thing => itemLower.includes(thing) || thing.includes(itemLower)) ? 'yes' : 'no';
+  }
+  
+  // Category questions
+  if (q.includes('animal') || q.includes('creature') || q.includes('living thing')) {
+    return category === 'animals' ? 'yes' : 'no';
+  }
+  
+  if (q.includes('food') || q.includes('eat') || q.includes('edible')) {
+    return category === 'food' ? 'yes' : 'no';
+  }
+  
+  if (q.includes('place') || q.includes('location') || q.includes('building')) {
+    return category === 'places' ? 'yes' : 'no';
+  }
+  
+  // Color questions
+  if (q.includes('red')) {
+    const redThings = ['apple', 'fire truck', 'rose', 'blood', 'strawberry', 'tomato'];
+    return redThings.some(thing => itemLower.includes(thing)) ? 'yes' : 'no';
+  }
+  
+  if (q.includes('blue')) {
+    const blueThings = ['ocean', 'sky', 'whale', 'blueberry'];
+    return blueThings.some(thing => itemLower.includes(thing)) ? 'yes' : 'no';
+  }
+  
+  if (q.includes('green')) {
+    const greenThings = ['tree', 'grass', 'frog', 'leaf', 'lettuce', 'cucumber'];
+    return greenThings.some(thing => itemLower.includes(thing)) ? 'yes' : 'no';
+  }
+  
+  // Physical properties
+  if (q.includes('fly') || q.includes('flies')) {
+    const flyingThings = ['bird', 'butterfly', 'bat', 'plane', 'helicopter', 'eagle', 'owl'];
+    return flyingThings.some(thing => itemLower.includes(thing)) ? 'yes' : 'no';
+  }
+  
+  if (q.includes('swim')) {
+    const swimmingThings = ['fish', 'dolphin', 'shark', 'whale', 'turtle', 'penguin'];
+    return swimmingThings.some(thing => itemLower.includes(thing)) ? 'yes' : 'no';
+  }
+  
+  if (q.includes('water')) {
+    const waterThings = ['ocean', 'river', 'fish', 'boat', 'swimming', 'whale', 'dolphin'];
+    return waterThings.some(thing => itemLower.includes(thing)) ? 'yes' : 'no';
+  }
+  
+  // Usage questions
+  if (q.includes('use') || q.includes('tool')) {
+    return category === 'objects' ? 'yes' : 'no';
+  }
+  
+  if (q.includes('electronic') || q.includes('electricity') || q.includes('power')) {
+    const electronicThings = ['phone', 'computer', 'tv', 'radio', 'camera', 'calculator', 'lamp'];
+    return electronicThings.some(thing => itemLower.includes(thing)) ? 'yes' : 'no';
+  }
+  
+  // Default responses for unhandled questions
+  const yesWords = ['can', 'does', 'has', 'would', 'could'];
+  const hasYesWord = yesWords.some(word => q.includes(word));
+  
+  // Give somewhat random but consistent answers for unrecognized questions
+  const hash = question.split('').reduce((a, b) => {
+    a = ((a << 5) - a) + b.charCodeAt(0);
+    return a & a;
+  }, 0);
+  
+  return Math.abs(hash) % 2 === 0 ? 'yes' : 'no';
+}
+
+// Format 20 questions display
+function formatTwentyQuestionsDisplay(gameState) {
+  const { questions, questionsLeft, gameOver, won, category, currentQuestion, guesses, finalGuess, item } = gameState;
+  
+  let display = `🤔 **20 Questions** (${20 - questionsLeft}/20 questions used)\n\n`;
+  
+  if (gameOver) {
+    if (won) {
+      display += `🎉 **You got it!** The answer was "${item}"!\n`;
+      display += `Solved in ${questions.length} questions!`;
+    } else {
+      display += `💀 **Game Over!** The answer was "${item}"\n`;
+      if (finalGuess) {
+        display += `Your guess: "${finalGuess}"`;
+      }
+    }
+  } else {
+    display += `**Category hint:** ${category}\n`;
+    display += `**Questions remaining:** ${questionsLeft}\n\n`;
+    
+    // Show recent questions
+    if (questions.length > 0) {
+      display += '**Recent questions:**\n';
+      const recentQuestions = questions.slice(-3); // Show last 3
+      for (const q of recentQuestions) {
+        display += `${q.questionNumber}. "${q.question}" → **${q.answer}**\n`;
+      }
+      display += '\n';
+    }
+    
+    if (currentQuestion) {
+      display += `Last answer: **${currentQuestion.answer}**\n\n`;
+    }
+    
+    if (questionsLeft > 0) {
+      display += '**Ask a yes/no question or make a guess!**\n';
+      display += 'Examples: "Is it alive?", "Is it bigger than a car?", "Is it a cat?"';
+    } else {
+      display += '**No questions left! What\'s your final guess?**';
+    }
+  }
+  
+  return display;
+}
+
+module.exports = {
+  createInitialTwentyQuestionsState,
+  askQuestion,
+  processGuess,
+  formatTwentyQuestionsDisplay,
+  getRandomItem,
+  CATEGORIES
+};

package/games/twotruths.js

@@ -0,0 +1,207 @@
+/**
+ * Two Truths and a Lie - Social ice breaker game for /vibe
+ *
+ * How it works:
+ * 1. One player shares 3 statements about themselves
+ * 2. Other players guess which one is the lie
+ * 3. Points for correct guesses, points for fooling others
+ */
+
+// Create initial game state
+function createInitialState(host) {
+  return {
+    host,
+    phase: 'setup', // setup, guessing, reveal
+    statements: [], // Array of 3 statements
+    lieIndex: null, // Which statement is the lie (0, 1, or 2)
+    guesses: {}, // { playerHandle: guessIndex }
+    scores: {}, // { playerHandle: score }
+    round: 1,
+    createdAt: new Date().toISOString()
+  };
+}
+
+// Host submits their 3 statements
+function submitStatements(gameState, statements, lieIndex) {
+  if (gameState.phase !== 'setup') {
+    return { error: 'Statements already submitted' };
+  }
+
+  if (!Array.isArray(statements) || statements.length !== 3) {
+    return { error: 'Must provide exactly 3 statements' };
+  }
+
+  if (lieIndex < 0 || lieIndex > 2) {
+    return { error: 'Lie index must be 0, 1, or 2' };
+  }
+
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      statements,
+      lieIndex,
+      phase: 'guessing'
+    }
+  };
+}
+
+// Player makes a guess
+function makeGuess(gameState, player, guessIndex) {
+  if (gameState.phase !== 'guessing') {
+    return { error: 'Not in guessing phase' };
+  }
+
+  if (player === gameState.host) {
+    return { error: 'Host cannot guess their own statements' };
+  }
+
+  if (guessIndex < 0 || guessIndex > 2) {
+    return { error: 'Guess must be 0, 1, or 2 (which statement is the lie)' };
+  }
+
+  const newGuesses = { ...gameState.guesses, [player]: guessIndex };
+
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      guesses: newGuesses
+    }
+  };
+}
+
+// Reveal the answer and calculate scores
+function reveal(gameState) {
+  if (gameState.phase !== 'guessing') {
+    return { error: 'Not in guessing phase' };
+  }
+
+  const { lieIndex, guesses, host } = gameState;
+  const newScores = { ...gameState.scores };
+
+  // Initialize host score if needed
+  if (!newScores[host]) newScores[host] = 0;
+
+  const correctGuessers = [];
+  const fooledPlayers = [];
+
+  for (const [player, guess] of Object.entries(guesses)) {
+    if (!newScores[player]) newScores[player] = 0;
+
+    if (guess === lieIndex) {
+      // Correct guess: +1 point to guesser
+      newScores[player] += 1;
+      correctGuessers.push(player);
+    } else {
+      // Wrong guess: +1 point to host for fooling them
+      newScores[host] += 1;
+      fooledPlayers.push(player);
+    }
+  }
+
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      phase: 'reveal',
+      scores: newScores
+    },
+    results: {
+      lieIndex,
+      lieStatement: gameState.statements[lieIndex],
+      correctGuessers,
+      fooledPlayers,
+      scores: newScores
+    }
+  };
+}
+
+// Start a new round with a new host
+function newRound(gameState, newHost) {
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      host: newHost,
+      phase: 'setup',
+      statements: [],
+      lieIndex: null,
+      guesses: {},
+      round: gameState.round + 1
+    }
+  };
+}
+
+// Format game display
+function formatDisplay(gameState, viewerHandle) {
+  const { host, phase, statements, guesses, scores, round, lieIndex } = gameState;
+  const isHost = viewerHandle === host;
+
+  let display = `🎭 **Two Truths and a Lie** (Round ${round})\n`;
+  display += `Host: @${host}\n\n`;
+
+  if (phase === 'setup') {
+    if (isHost) {
+      display += `**Your turn!** Share 3 statements about yourself.\n`;
+      display += `Use: \`vibe twotruths --statements "truth1" "truth2" "lie" --lie 2\`\n`;
+      display += `(--lie indicates which statement number is the lie: 0, 1, or 2)\n`;
+    } else {
+      display += `Waiting for @${host} to share their statements...\n`;
+    }
+  } else if (phase === 'guessing') {
+    display += `**Which one is the lie?**\n\n`;
+    statements.forEach((stmt, i) => {
+      const marker = isHost ? (i === lieIndex ? '🤫' : '✓') : `${i + 1}.`;
+      display += `${marker} ${stmt}\n`;
+    });
+    display += '\n';
+
+    if (isHost) {
+      const guessCount = Object.keys(guesses).length;
+      display += `${guessCount} player(s) have guessed.\n`;
+      display += `Use \`vibe twotruths --reveal\` when ready to reveal!\n`;
+    } else {
+      if (guesses[viewerHandle] !== undefined) {
+        display += `✓ You guessed statement #${guesses[viewerHandle] + 1}\n`;
+      } else {
+        display += `Use \`vibe twotruths --guess 1\` (or 2 or 3) to guess the lie!\n`;
+      }
+    }
+  } else if (phase === 'reveal') {
+    display += `**The lie was:**\n`;
+    statements.forEach((stmt, i) => {
+      const marker = i === lieIndex ? '❌ LIE:' : '✓ TRUE:';
+      display += `${marker} ${stmt}\n`;
+    });
+    display += '\n';
+
+    // Show who guessed what
+    display += `**Guesses:**\n`;
+    for (const [player, guess] of Object.entries(guesses)) {
+      const correct = guess === lieIndex;
+      display += `@${player}: #${guess + 1} ${correct ? '✓' : '✗'}\n`;
+    }
+    display += '\n';
+
+    // Show scores
+    display += `**Scores:**\n`;
+    const sortedScores = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+    sortedScores.forEach(([player, score]) => {
+      display += `@${player}: ${score} pts\n`;
+    });
+
+    display += `\nUse \`vibe twotruths --newround @someone\` to start next round!\n`;
+  }
+
+  return display;
+}
+
+module.exports = {
+  createInitialState,
+  submitStatements,
+  makeGuess,
+  reveal,
+  newRound,
+  formatDisplay
+};