slashvibe-mcp 0.3.21 → 0.3.23

package/games/twentyquestions.js

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

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