slashvibe-mcp 0.3.20 → 0.3.21

package/games/storybuilder.js

@@ -0,0 +1,343 @@
+/**
+ * Story Builder game implementation for /vibe
+ * A collaborative storytelling game where players take turns adding one sentence
+ * Build creative stories together with friends!
+ */
+
+// Story prompts to help start interesting stories
+const STORY_PROMPTS = [
+  "It was a dark and stormy night when the mysterious package arrived...",
+  "The old lighthouse keeper discovered something impossible in the basement...",
+  "Sarah woke up to find that everyone in town had vanished except her...",
+  "The time machine worked perfectly, except for one small problem...",
+  "The AI assistant started behaving strangely after the update...",
+  "In the year 2087, the last library on Earth received an unexpected visitor...",
+  "The cat came home wearing a tiny suit and carrying a briefcase...",
+  "When the elevator doors opened on floor 13, it wasn't floor 13 at all...",
+  "The dragon apologized profusely for burning down the village...",
+  "Every mirror in the house started showing a different reflection...",
+  "The food truck only appeared at midnight, and only sold memories...",
+  "After 20 years in space, the astronaut returned to find Earth very different...",
+  "The magic spell worked, but not quite as intended...",
+  "The robot barista made the perfect coffee, but refused to serve humans...",
+  "Deep in the Amazon, the explorer found a city that didn't exist on any map..."
+];
+
+// Story genres and their characteristics
+const GENRES = {
+  mystery: {
+    name: "Mystery",
+    prompts: [
+      "The detective found a clue that changed everything...",
+      "The locked room had no windows, no secret passages, yet someone had escaped...",
+      "The witness's story had one fatal flaw..."
+    ],
+    endings: ["Who was the real culprit?", "What was the missing piece?", "How did they solve the case?"]
+  },
+  scifi: {
+    name: "Science Fiction", 
+    prompts: [
+      "The spacecraft's AI began questioning its own programming...",
+      "The new planet looked perfect for colonization, until they discovered...",
+      "Time travel was possible, but came with unexpected consequences..."
+    ],
+    endings: ["What did technology make possible?", "How did they adapt to the future?", "What was discovered in space?"]
+  },
+  fantasy: {
+    name: "Fantasy",
+    prompts: [
+      "The ancient prophecy was coming true, but backwards...",
+      "The wizard's apprentice accidentally unleashed something from the forbidden grimoire...",
+      "The enchanted forest began whispering warnings to travelers..."
+    ],
+    endings: ["What magical power was revealed?", "How was the kingdom saved?", "What did the prophecy really mean?"]
+  },
+  comedy: {
+    name: "Comedy",
+    prompts: [
+      "The superhero's greatest weakness turned out to be absolutely ridiculous...",
+      "The cooking show went horribly wrong when the mystery ingredient was revealed...",
+      "The world's worst spy somehow kept succeeding by accident..."
+    ],
+    endings: ["What was the hilarious misunderstanding?", "How did chaos lead to success?", "What was the ridiculous twist?"]
+  }
+};
+
+// Create initial story builder state
+function createInitialStoryBuilderState(genre = null, customPrompt = null) {
+  let prompt;
+  let selectedGenre = 'general';
+  
+  if (customPrompt) {
+    prompt = customPrompt;
+    selectedGenre = 'custom';
+  } else if (genre && GENRES[genre]) {
+    selectedGenre = genre;
+    const genrePrompts = GENRES[genre].prompts;
+    prompt = genrePrompts[Math.floor(Math.random() * genrePrompts.length)];
+  } else {
+    prompt = STORY_PROMPTS[Math.floor(Math.random() * STORY_PROMPTS.length)];
+  }
+
+  return {
+    sentences: [prompt],
+    players: [],
+    currentPlayer: null,
+    moves: 1, // Prompt counts as move 1
+    gameOver: false,
+    maxSentences: 20, // End after 20 sentences for now
+    genre: selectedGenre,
+    playerTurnIndex: 0,
+    prompt: prompt,
+    createdAt: new Date().toISOString(),
+    lastActivity: new Date().toISOString(),
+    wordCount: prompt.split(' ').length
+  };
+}
+
+// Add player to story
+function addPlayer(gameState, playerHandle) {
+  if (gameState.players.includes(playerHandle)) {
+    return { error: 'Player already in the story!' };
+  }
+
+  if (gameState.players.length >= 8) {
+    return { error: 'Story is full (max 8 storytellers)' };
+  }
+
+  const newPlayers = [...gameState.players, playerHandle];
+  
+  return {
+    success: true,
+    gameState: {
+      ...gameState,
+      players: newPlayers,
+      currentPlayer: gameState.currentPlayer || playerHandle // First player starts
+    }
+  };
+}
+
+// Add a sentence to the story
+function addSentence(gameState, sentence, playerHandle) {
+  const { sentences, players, currentPlayer, moves, maxSentences } = gameState;
+  
+  // Clean and validate sentence
+  const cleanSentence = sentence.trim();
+  
+  if (!cleanSentence) {
+    return { error: 'Sentence cannot be empty!' };
+  }
+  
+  if (cleanSentence.length > 500) {
+    return { error: 'Sentence too long! Keep it under 500 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}` };
+  }
+  
+  // Add proper punctuation if missing
+  let finalSentence = cleanSentence;
+  if (!/[.!?]$/.test(finalSentence)) {
+    finalSentence += '.';
+  }
+  
+  // Update story
+  const newSentences = [...sentences, finalSentence];
+  const newMoves = moves + 1;
+  const newWordCount = gameState.wordCount + finalSentence.split(' ').length;
+  
+  // 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 story should end
+  const shouldEnd = newMoves >= maxSentences;
+  
+  const newGameState = {
+    ...gameState,
+    sentences: newSentences,
+    currentPlayer: shouldEnd ? null : nextPlayer,
+    playerTurnIndex: nextPlayerIndex,
+    moves: newMoves,
+    gameOver: shouldEnd,
+    lastActivity: new Date().toISOString(),
+    wordCount: newWordCount,
+    lastContributor: playerHandle
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Format story builder display
+function formatStoryBuilderDisplay(gameState) {
+  const { sentences, players, currentPlayer, moves, gameOver, maxSentences, genre, wordCount, prompt } = gameState;
+  
+  let display = `📖 **Collaborative Story** (${moves}/${maxSentences} sentences)\n\n`;
+  
+  if (genre !== 'general' && genre !== 'custom') {
+    display += `**Genre:** ${GENRES[genre]?.name || genre}\n\n`;
+  }
+  
+  if (gameOver) {
+    display += '🎉 **Story Complete!** What an adventure!\n\n';
+  }
+  
+  // Show the story
+  display += '**The Story So Far:**\n';
+  display += '```\n';
+  
+  // Show all sentences with paragraph breaks every 3-4 sentences
+  let storyText = '';
+  for (let i = 0; i < sentences.length; i++) {
+    storyText += sentences[i];
+    
+    // Add paragraph break every 3-4 sentences for readability
+    if ((i + 1) % 3 === 0 && i < sentences.length - 1) {
+      storyText += '\n\n';
+    } else if (i < sentences.length - 1) {
+      storyText += ' ';
+    }
+  }
+  
+  display += storyText + '\n```\n\n';
+  
+  // Show stats
+  display += `**Stats:** ${sentences.length} sentences, ${wordCount} words\n\n`;
+  
+  // Show players if multiplayer
+  if (players.length > 1) {
+    display += `**Storytellers (${players.length}):** ${players.map(p => `@${p}`).join(', ')}\n\n`;
+  }
+  
+  if (!gameOver) {
+    if (players.length > 1) {
+      display += `**@${currentPlayer}, continue the story!**\n`;
+    } else if (players.length === 1) {
+      display += '**Your turn! Add the next sentence.**\n';
+    } else {
+      display += '**Join the story and add the next sentence!**\n';
+    }
+    
+    // Show helpful prompts based on story length
+    if (sentences.length < 5) {
+      display += 'Building the scene...';
+    } else if (sentences.length < 10) {
+      display += 'Developing the plot...';
+    } else if (sentences.length < 15) {
+      display += 'Heading toward the climax...';
+    } else {
+      display += 'Time to wrap up the story!';
+    }
+  } else {
+    // Show completion message with genre-specific ending questions
+    if (genre && GENRES[genre] && GENRES[genre].endings) {
+      const endings = GENRES[genre].endings;
+      const randomEnding = endings[Math.floor(Math.random() * endings.length)];
+      display += `**Reflection:** ${randomEnding}`;
+    } else {
+      display += '**What a creative journey! Thanks to all the storytellers!**';
+    }
+  }
+  
+  return display;
+}
+
+// Get story statistics
+function getStoryStats(gameState) {
+  const { sentences, players } = gameState;
+  
+  if (sentences.length <= 1) return null; // Just the prompt
+  
+  // Calculate statistics
+  const totalWords = gameState.wordCount;
+  const avgWordsPerSentence = Math.round(totalWords / sentences.length);
+  
+  // Find longest and shortest sentences
+  let longest = '';
+  let shortest = sentences[0];
+  
+  for (const sentence of sentences) {
+    if (sentence.length > longest.length) {
+      longest = sentence;
+    }
+    if (sentence.length < shortest.length && sentence !== gameState.prompt) {
+      shortest = sentence;
+    }
+  }
+  
+  return {
+    totalSentences: sentences.length,
+    totalWords: totalWords,
+    avgWordsPerSentence,
+    longestSentence: longest.substring(0, 50) + (longest.length > 50 ? '...' : ''),
+    shortestSentence: shortest.substring(0, 50) + (shortest.length > 50 ? '...' : ''),
+    contributors: players.length
+  };
+}
+
+// Suggest story themes based on content
+function analyzeStoryThemes(gameState) {
+  const { sentences } = gameState;
+  const storyText = sentences.join(' ').toLowerCase();
+  
+  const themes = [];
+  
+  // Look for common themes
+  if (/(magic|wizard|spell|dragon|knight|castle|potion)/.test(storyText)) {
+    themes.push('🏰 Fantasy Adventure');
+  }
+  
+  if (/(space|robot|future|technology|alien|planet|laser)/.test(storyText)) {
+    themes.push('🚀 Science Fiction');
+  }
+  
+  if (/(detective|mystery|clue|suspect|murder|crime)/.test(storyText)) {
+    themes.push('🔍 Mystery & Crime');
+  }
+  
+  if (/(funny|hilarious|ridiculous|silly|comedy|laugh)/.test(storyText)) {
+    themes.push('😂 Comedy');
+  }
+  
+  if (/(love|romance|heart|kiss|wedding|date)/.test(storyText)) {
+    themes.push('💕 Romance');
+  }
+  
+  if (/(ghost|spirit|haunted|scary|supernatural|witch)/.test(storyText)) {
+    themes.push('👻 Supernatural');
+  }
+  
+  if (/(adventure|journey|travel|explore|quest|treasure)/.test(storyText)) {
+    themes.push('🗺️ Adventure');
+  }
+  
+  return themes;
+}
+
+// Get random prompt by genre
+function getRandomPrompt(genre = null) {
+  if (genre && GENRES[genre]) {
+    const prompts = GENRES[genre].prompts;
+    return prompts[Math.floor(Math.random() * prompts.length)];
+  }
+  return STORY_PROMPTS[Math.floor(Math.random() * STORY_PROMPTS.length)];
+}
+
+module.exports = {
+  createInitialStoryBuilderState,
+  addPlayer,
+  addSentence,
+  formatStoryBuilderDisplay,
+  getStoryStats,
+  analyzeStoryThemes,
+  getRandomPrompt,
+  STORY_PROMPTS,
+  GENRES
+};

package/games/tictactoe.js

@@ -0,0 +1,345 @@
+/**
+ * Tic-Tac-Toe game implementation for /vibe
+ * Classic 3x3 grid game with AI opponent support
+ * Includes multiple difficulty levels: easy, medium, hard
+ */
+
+// Create initial tic-tac-toe state
+function createInitialTicTacToeState(difficulty = 'medium') {
+  return {
+    board: Array(9).fill(''), // 3x3 grid as flat array
+    turn: 'X', // X always goes first
+    moves: 0,
+    winner: null,
+    gameOver: false,
+    isDraw: false,
+    playerSymbol: 'X', // Player is X, AI is O
+    aiSymbol: 'O',
+    difficulty: difficulty // easy, medium, hard
+  };
+}
+
+// Check for winner in tic-tac-toe
+function checkWinner(board) {
+  const lines = [
+    [0, 1, 2], [3, 4, 5], [6, 7, 8], // rows
+    [0, 3, 6], [1, 4, 7], [2, 5, 8], // cols
+    [0, 4, 8], [2, 4, 6]             // diagonals
+  ];
+
+  for (const [a, b, c] of lines) {
+    if (board[a] && board[a] === board[b] && board[a] === board[c]) {
+      return board[a];
+    }
+  }
+
+  return null;
+}
+
+// Make a move
+function makeMove(gameState, position, playerSymbol) {
+  const { board, moves, winner, gameOver } = gameState;
+  
+  // Validate move
+  if (gameOver) {
+    return { error: 'Game is already over' };
+  }
+  
+  if (position < 1 || position > 9) {
+    return { error: 'Position must be 1-9' };
+  }
+  
+  const index = position - 1; // Convert to 0-based index
+  
+  if (board[index]) {
+    return { error: 'Position already taken' };
+  }
+
+  // Make the move
+  const newBoard = [...board];
+  newBoard[index] = playerSymbol;
+  
+  const newMoves = moves + 1;
+  const newWinner = checkWinner(newBoard);
+  const newIsDraw = !newWinner && newBoard.every(cell => cell !== '');
+  const newGameOver = newWinner || newIsDraw;
+  const nextTurn = playerSymbol === 'X' ? 'O' : 'X';
+  
+  const newGameState = {
+    ...gameState,
+    board: newBoard,
+    turn: newGameOver ? playerSymbol : nextTurn,
+    moves: newMoves,
+    winner: newWinner,
+    gameOver: newGameOver,
+    isDraw: newIsDraw,
+    lastMove: { position, symbol: playerSymbol }
+  };
+  
+  return { success: true, gameState: newGameState };
+}
+
+// Minimax algorithm for perfect AI play (hard difficulty)
+function minimax(board, depth, isMaximizing, aiSymbol, playerSymbol, alpha = -Infinity, beta = Infinity) {
+  const winner = checkWinner(board);
+  
+  // Base cases
+  if (winner === aiSymbol) return 10 - depth;
+  if (winner === playerSymbol) return depth - 10;
+  if (board.every(cell => cell !== '')) return 0; // Draw
+  
+  if (isMaximizing) {
+    let maxEval = -Infinity;
+    for (let i = 0; i < 9; i++) {
+      if (board[i] === '') {
+        board[i] = aiSymbol;
+        const eval = minimax(board, depth + 1, false, aiSymbol, playerSymbol, alpha, beta);
+        board[i] = '';
+        maxEval = Math.max(maxEval, eval);
+        alpha = Math.max(alpha, eval);
+        if (beta <= alpha) break; // Alpha-beta pruning
+      }
+    }
+    return maxEval;
+  } else {
+    let minEval = Infinity;
+    for (let i = 0; i < 9; i++) {
+      if (board[i] === '') {
+        board[i] = playerSymbol;
+        const eval = minimax(board, depth + 1, true, aiSymbol, playerSymbol, alpha, beta);
+        board[i] = '';
+        minEval = Math.min(minEval, eval);
+        beta = Math.min(beta, eval);
+        if (beta <= alpha) break; // Alpha-beta pruning
+      }
+    }
+    return minEval;
+  }
+}
+
+// Get best move using minimax (for hard difficulty)
+function getBestMove(board, aiSymbol, playerSymbol) {
+  let bestMove = -1;
+  let bestValue = -Infinity;
+  
+  for (let i = 0; i < 9; i++) {
+    if (board[i] === '') {
+      board[i] = aiSymbol;
+      const moveValue = minimax(board, 0, false, aiSymbol, playerSymbol);
+      board[i] = '';
+      
+      if (moveValue > bestValue) {
+        bestMove = i + 1; // Convert to 1-based index
+        bestValue = moveValue;
+      }
+    }
+  }
+  
+  return bestMove;
+}
+
+// AI Strategy with difficulty levels
+function getAIMove(gameState, difficulty = 'medium') {
+  const { board, aiSymbol, playerSymbol } = gameState;
+  const availablePositions = getAvailablePositions(board);
+  
+  if (availablePositions.length === 0) {
+    return null;
+  }
+
+  // Override difficulty if specified in gameState
+  if (gameState.difficulty) {
+    difficulty = gameState.difficulty;
+  }
+
+  switch (difficulty) {
+    case 'easy':
+      return getEasyAIMove(board, availablePositions, aiSymbol, playerSymbol);
+    case 'medium':
+      return getMediumAIMove(board, availablePositions, aiSymbol, playerSymbol);
+    case 'hard':
+      return getHardAIMove(board, aiSymbol, playerSymbol);
+    default:
+      return getMediumAIMove(board, availablePositions, aiSymbol, playerSymbol);
+  }
+}
+
+// Easy AI: Mostly random with occasional smart moves
+function getEasyAIMove(board, availablePositions, aiSymbol, playerSymbol) {
+  // 70% chance to play randomly
+  if (Math.random() < 0.7) {
+    const randomIndex = Math.floor(Math.random() * availablePositions.length);
+    return availablePositions[randomIndex];
+  }
+  
+  // 30% chance to make a smart move
+  // 1. Try to win (15% chance)
+  if (Math.random() < 0.5) {
+    for (const pos of availablePositions) {
+      const testBoard = [...board];
+      testBoard[pos - 1] = aiSymbol;
+      if (checkWinner(testBoard) === aiSymbol) {
+        return pos;
+      }
+    }
+  }
+  
+  // 2. Sometimes block player (15% chance)
+  if (Math.random() < 0.5) {
+    for (const pos of availablePositions) {
+      const testBoard = [...board];
+      testBoard[pos - 1] = playerSymbol;
+      if (checkWinner(testBoard) === playerSymbol) {
+        return pos;
+      }
+    }
+  }
+  
+  // Fallback to random
+  const randomIndex = Math.floor(Math.random() * availablePositions.length);
+  return availablePositions[randomIndex];
+}
+
+// Medium AI: Balanced strategy with some randomness
+function getMediumAIMove(board, availablePositions, aiSymbol, playerSymbol) {
+  // 1. Always try to win first
+  for (const pos of availablePositions) {
+    const testBoard = [...board];
+    testBoard[pos - 1] = aiSymbol;
+    if (checkWinner(testBoard) === aiSymbol) {
+      return pos;
+    }
+  }
+
+  // 2. Always block player from winning
+  for (const pos of availablePositions) {
+    const testBoard = [...board];
+    testBoard[pos - 1] = playerSymbol;
+    if (checkWinner(testBoard) === playerSymbol) {
+      return pos;
+    }
+  }
+
+  // 3. Add some randomness to avoid being too predictable (30% chance)
+  if (Math.random() < 0.3) {
+    const randomIndex = Math.floor(Math.random() * availablePositions.length);
+    return availablePositions[randomIndex];
+  }
+
+  // 4. Take center if available
+  if (availablePositions.includes(5)) {
+    return 5;
+  }
+
+  // 5. Take corners
+  const corners = [1, 3, 7, 9];
+  const availableCorners = corners.filter(c => availablePositions.includes(c));
+  if (availableCorners.length > 0) {
+    const randomCorner = availableCorners[Math.floor(Math.random() * availableCorners.length)];
+    return randomCorner;
+  }
+
+  // 6. Take any remaining position
+  const randomIndex = Math.floor(Math.random() * availablePositions.length);
+  return availablePositions[randomIndex];
+}
+
+// Hard AI: Perfect play using minimax algorithm
+function getHardAIMove(board, aiSymbol, playerSymbol) {
+  return getBestMove(board, aiSymbol, playerSymbol);
+}
+
+// Make AI move
+function makeAIMove(gameState, difficulty = null) {
+  if (gameState.gameOver || gameState.turn !== gameState.aiSymbol) {
+    return { error: 'Not AI turn or game is over' };
+  }
+
+  const aiPosition = getAIMove(gameState, difficulty);
+  if (!aiPosition) {
+    return { error: 'No moves available' };
+  }
+
+  return makeMove(gameState, aiPosition, gameState.aiSymbol);
+}
+
+// Format tic-tac-toe board for display
+function formatTicTacToeDisplay(gameState) {
+  const { board, moves, winner, isDraw, turn, lastMove, playerSymbol, aiSymbol, difficulty } = gameState;
+  
+  const difficultyEmoji = {
+    'easy': '😊',
+    'medium': '🤔',
+    'hard': '🧠'
+  };
+  
+  const difficultyText = difficulty ? `${difficultyEmoji[difficulty] || '🤔'} ${difficulty.toUpperCase()}` : 'MEDIUM 🤔';
+  
+  let display = `🎯 **Tic-Tac-Toe vs AI** (${difficultyText}) - ${moves} moves\n\n`;
+  
+  // Create 3x3 grid display
+  const symbols = board.map((cell, i) => cell || (i + 1).toString());
+  
+  display += '```\n';
+  for (let row = 0; row < 3; row++) {
+    const line = [];
+    for (let col = 0; col < 3; col++) {
+      const index = row * 3 + col;
+      line.push(symbols[index]);
+    }
+    display += line.join(' │ ') + '\n';
+    if (row < 2) display += '──┼───┼──\n';
+  }
+  display += '```\n\n';
+  
+  if (winner) {
+    if (winner === playerSymbol) {
+      display += `🎉 **You won!** Great job!`;
+    } else {
+      display += `🤖 **AI wins!** Better luck next time!`;
+    }
+  } else if (isDraw) {
+    display += `🤝 **Draw!** Well played!`;
+  } else {
+    if (turn === playerSymbol) {
+      display += `Your turn! Choose position 1-9`;
+    } else {
+      display += `AI is thinking... 🤔`;
+    }
+    
+    if (lastMove) {
+      const mover = lastMove.symbol === playerSymbol ? 'You' : 'AI';
+      display += `\nLast move: ${mover} played ${lastMove.symbol} at position ${lastMove.position}`;
+    }
+  }
+  
+  return display;
+}
+
+// Get available positions
+function getAvailablePositions(board) {
+  return board
+    .map((cell, index) => cell === '' ? index + 1 : null)
+    .filter(pos => pos !== null);
+}
+
+// Get difficulty description for users
+function getDifficultyDescription(difficulty) {
+  const descriptions = {
+    'easy': '😊 **EASY**: AI plays mostly randomly, great for beginners!',
+    'medium': '🤔 **MEDIUM**: AI uses basic strategy but makes some mistakes.',
+    'hard': '🧠 **HARD**: AI plays perfectly, can you beat it?'
+  };
+  return descriptions[difficulty] || descriptions['medium'];
+}
+
+module.exports = {
+  createInitialTicTacToeState,
+  makeMove,
+  makeAIMove,
+  formatTicTacToeDisplay,
+  checkWinner,
+  getAvailablePositions,
+  getAIMove,
+  getDifficultyDescription
+};