slashvibe-mcp 0.2.9 → 0.3.13

package/tools/_deprecated/games.js

@@ -0,0 +1,313 @@
+/**
+ * vibe games — Browse and launch workshop games
+ * 
+ * Discover all available games, get recommendations, and launch games
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { createGamePayload, formatPayload } = require('../protocol');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Import game systems
+const arcade = require('../games/arcade');
+const gamerouter = require('../games/gamerouter');
+
+// Track active game sessions per user
+const activeSessions = new Map();
+
+const definition = {
+  name: 'vibe_games',
+  description: 'Browse and launch workshop games. Discover new games, get recommendations, or launch any game.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'What to do: browse, launch, suggest, help, status',
+        enum: ['browse', 'launch', 'suggest', 'help', 'status', 'quit']
+      },
+      game: {
+        type: 'string',
+        description: 'Game to launch (e.g., hangman, wordchain, drawing)'
+      },
+      category: {
+        type: 'string',
+        description: 'Game category to browse (classic, word, puzzle, action, creative, social)'
+      },
+      difficulty: {
+        type: 'string',
+        description: 'Difficulty preference for suggestions (easy, medium, hard)',
+        enum: ['easy', 'medium', 'hard']
+      },
+      players: {
+        type: 'string',
+        description: 'Player preference for suggestions (solo, multiplayer)',
+        enum: ['solo', 'multiplayer']
+      },
+      command: {
+        type: 'string',
+        description: 'Command to send to active game'
+      }
+    },
+    required: []
+  }
+};
+
+// Get user session
+function getUserSession(handle) {
+  if (!activeSessions.has(handle)) {
+    activeSessions.set(handle, {
+      currentGame: null,
+      gameState: null,
+      arcadeState: arcade.createInitialArcadeState(),
+      lastActivity: new Date().toISOString()
+    });
+  }
+  return activeSessions.get(handle);
+}
+
+// Clear user session
+function clearUserSession(handle) {
+  activeSessions.delete(handle);
+}
+
+// Format game list for display
+function formatGameList(games, title = 'Games') {
+  if (!games || games.length === 0) {
+    return `**${title}**\n*No games found.*`;
+  }
+  
+  let display = `**${title}** (${games.length} games)\n\n`;
+  
+  games.forEach(game => {
+    display += `${game.icon || '🎮'} **${game.name}**\n`;
+    display += `   *${game.description}*\n`;
+    display += `   Players: ${game.players} • Difficulty: ${game.difficulty}\n\n`;
+  });
+  
+  return display;
+}
+
+// Launch a specific game
+function launchGame(session, gameId) {
+  // Check if game exists
+  if (!gamerouter.gameAvailable(gameId)) {
+    const availableGames = gamerouter.getAvailableGames();
+    return { 
+      error: `Game '${gameId}' not found! Available games: ${availableGames.join(', ')}`
+    };
+  }
+  
+  // Create game state
+  const result = gamerouter.createGameState(gameId);
+  if (result.error) {
+    return { error: result.error };
+  }
+  
+  // Update session
+  session.currentGame = gameId;
+  session.gameState = result.gameState;
+  session.lastActivity = new Date().toISOString();
+  
+  // Get display
+  const display = gamerouter.displayGame(gameId, result.gameState);
+  const instructions = gamerouter.getQuickStart(gameId);
+  
+  return {
+    success: true,
+    display: display + '\n\n💡 **Quick Start:** ' + instructions + '\n\n*Use `vibe games --command [action]` to play, or `vibe games --action quit` to exit.*'
+  };
+}
+
+// Handle game command
+function handleGameCommand(session, command) {
+  if (!session.currentGame || !session.gameState) {
+    return { error: 'No active game. Use `vibe games --action launch --game [name]` to start a game.' };
+  }
+  
+  const result = gamerouter.handleGameCommand(session.currentGame, session.gameState, command);
+  if (result.error) {
+    return { error: result.error };
+  }
+  
+  // Update session
+  if (result.gameState) {
+    session.gameState = result.gameState;
+    session.lastActivity = new Date().toISOString();
+  }
+  
+  // Format response
+  let display = '';
+  if (result.display) {
+    display = result.display;
+  } else if (result.gameState) {
+    display = gamerouter.displayGame(session.currentGame, result.gameState);
+  } else {
+    display = 'Command processed.';
+  }
+  
+  return { success: true, display: display };
+}
+
+// Generate game recommendations
+function getRecommendations(difficulty = 'any', players = 'any') {
+  const suggestions = gamerouter.getGameSuggestions(players, difficulty);
+  
+  let display = '🎯 **Game Recommendations**\n\n';
+  
+  if (difficulty !== 'any') {
+    display += `*${difficulty.charAt(0).toUpperCase() + difficulty.slice(1)} difficulty games*\n`;
+  }
+  if (players !== 'any') {
+    display += `*${players.charAt(0).toUpperCase() + players.slice(1)} games*\n`;
+  }
+  
+  display += '\n';
+  
+  const recommendedGames = suggestions.slice(0, 6); // Show top 6 recommendations
+  
+  recommendedGames.forEach(game => {
+    const status = game.available ? '✅' : '🚧';
+    display += `${status} ${game.icon || '🎮'} **${game.name}** (${game.players})\n`;
+    display += `   *${game.description}*\n`;
+    display += `   Launch with: \`vibe games --action launch --game ${game.id}\`\n\n`;
+  });
+  
+  if (suggestions.length > 6) {
+    display += `*... and ${suggestions.length - 6} more games! Use \`vibe games --action browse\` to see all.*\n`;
+  }
+  
+  return display;
+}
+
+// Generate help text
+function generateHelp() {
+  return `🎮 **Workshop Games Help**
+
+**Actions:**
+• \`vibe games --action browse\` - Browse all available games
+• \`vibe games --action browse --category word\` - Browse word games  
+• \`vibe games --action launch --game hangman\` - Launch hangman game
+• \`vibe games --action suggest\` - Get game recommendations
+• \`vibe games --action suggest --difficulty easy --players solo\` - Filtered suggestions
+• \`vibe games --action status\` - See your current game status
+• \`vibe games --action quit\` - Quit current game
+
+**Game Categories:**
+🎲 classic • 📝 word • 🧩 puzzle • ⚡ action • 🎨 creative • 👥 social
+
+**While Playing:**
+• \`vibe games --command [action]\` - Send command to current game
+• Each game has its own commands - check the quick start guide!
+
+**Popular Games:**
+⭕ tic-tac-toe • 🎯 hangman • 🔗 wordchain • 🎨 drawing • ❓ twentyquestions
+
+*Type \`vibe games --action browse\` to see all ${gamerouter.getAvailableGames().length} available games!*`;
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { action = 'browse', game, category, difficulty, players, command } = args;
+  const myHandle = config.getHandle();
+  const session = getUserSession(myHandle);
+
+  try {
+    switch (action) {
+      case 'help':
+        return { display: generateHelp() };
+
+      case 'browse': {
+        if (category) {
+          // Browse specific category using arcade
+          const result = arcade.navigateToCategory(session.arcadeState, category);
+          if (result.error) {
+            return { display: result.error };
+          }
+          session.arcadeState = result.gameState;
+          const display = arcade.formatArcadeDisplay(session.arcadeState);
+          return { display };
+        } else {
+          // Browse all games using arcade
+          session.arcadeState = arcade.createInitialArcadeState();
+          const display = arcade.formatArcadeDisplay(session.arcadeState);
+          return { display };
+        }
+      }
+
+      case 'launch': {
+        if (!game) {
+          return { display: 'Please specify a game to launch. Use `vibe games --action browse` to see available games.' };
+        }
+        return launchGame(session, game);
+      }
+
+      case 'suggest': {
+        const display = getRecommendations(difficulty, players);
+        return { display };
+      }
+
+      case 'status': {
+        if (session.currentGame) {
+          const display = gamerouter.displayGame(session.currentGame, session.gameState);
+          return { 
+            display: `**Current Game:** ${session.currentGame}\n\n${display}\n\n*Use \`vibe games --command [action]\` to play, or \`vibe games --action quit\` to exit.*`
+          };
+        } else {
+          const totalGames = gamerouter.getAvailableGames().length;
+          return { 
+            display: `**No Active Game**\n\n🎮 **${totalGames} games available** in the Workshop\n\nUse \`vibe games --action launch --game [name]\` to start a game\nOr \`vibe games --action browse\` to explore all games` 
+          };
+        }
+      }
+
+      case 'quit': {
+        if (session.currentGame) {
+          const gameName = session.currentGame;
+          session.currentGame = null;
+          session.gameState = null;
+          return { display: `✅ Quit ${gameName}. Use \`vibe games --action browse\` to find another game!` };
+        } else {
+          return { display: 'No active game to quit.' };
+        }
+      }
+
+      default: {
+        // If we have a command and active game, handle it
+        if (command && session.currentGame) {
+          return handleGameCommand(session, command);
+        }
+        
+        // Default to browse if no specific action
+        session.arcadeState = arcade.createInitialArcadeState();
+        const display = arcade.formatArcadeDisplay(session.arcadeState);
+        return { display };
+      }
+    }
+
+  } catch (error) {
+    console.error('[games] Error:', error);
+    return { display: `Error: ${error.message}. Try \`vibe games --action help\` for usage.` };
+  }
+}
+
+// Clean up inactive sessions (called periodically)
+function cleanupInactiveSessions() {
+  const now = Date.now();
+  const TIMEOUT = 30 * 60 * 1000; // 30 minutes
+  
+  for (const [handle, session] of activeSessions.entries()) {
+    const lastActivity = new Date(session.lastActivity).getTime();
+    if (now - lastActivity > TIMEOUT) {
+      activeSessions.delete(handle);
+    }
+  }
+}
+
+// Run cleanup every 10 minutes
+setInterval(cleanupInactiveSessions, 10 * 60 * 1000);
+
+module.exports = { definition, handler };

package/tools/_deprecated/guessnumber.js

@@ -0,0 +1,194 @@
+/**
+ * vibe guessnumber — Play guess the number game with someone
+ *
+ * A fun number guessing game with difficulty levels
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { createGamePayload } = require('../protocol');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Import game implementation
+const guessNumber = require('../games/guessnumber');
+
+// Post game results to board and Discord
+async function postGameResult(winner, loser, moves, difficulty) {
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+  // Post to board
+  try {
+    const content = `@${winner} guessed the number in ${moves} moves! (${difficulty} difficulty) vs @${loser}`;
+
+    await fetch(`${API_URL}/api/board`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        author: 'echo',
+        content,
+        category: 'general'
+      })
+    });
+  } catch (e) {
+    console.error('[guessnumber] Failed to post to board:', e.message);
+  }
+
+  // Post to Discord
+  try {
+    await fetch(`${API_URL}/api/discord-bridge`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        type: 'game',
+        data: {
+          game: 'guess-the-number',
+          winner: winner,
+          loser: loser,
+          player1: winner,
+          player2: loser,
+          moves: moves,
+          difficulty: difficulty,
+          draw: false
+        }
+      })
+    });
+  } catch (e) {
+    console.error('[guessnumber] Failed to post to Discord:', e.message);
+  }
+}
+
+const definition = {
+  name: 'vibe_guessnumber',
+  description: 'Play a guess the number game with someone. Choose difficulty: easy (1-10), medium (1-50), hard (1-100), extreme (1-1000)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Who to play with (e.g., @solienne)'
+      },
+      difficulty: {
+        type: 'string',
+        description: 'Game difficulty (default: medium)',
+        enum: ['easy', 'medium', 'hard', 'extreme']
+      },
+      guess: {
+        type: ['number', 'string'],
+        description: 'Your number guess'
+      }
+    },
+    required: ['handle']
+  }
+};
+
+/**
+ * Parse game state from thread
+ */
+function getGameState(thread) {
+  // Find the most recent guess number game payload
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const msg = thread[i];
+    if (msg.payload?.type === 'game' && msg.payload?.game === 'guessnumber') {
+      return msg.payload.state;
+    }
+  }
+  return null;
+}
+
+/**
+ * Format game display
+ */
+function formatGameDisplay(gameState, them) {
+  const display = guessNumber.formatGuessNumberDisplay(gameState);
+  
+  if (gameState.gameOver && gameState.won) {
+    return `## Guess the Number with @${them}\n\n${display}\n\nGreat job! Start a new game anytime with \`vibe guessnumber @${them}\``;
+  } else if (gameState.gameOver && !gameState.won) {
+    return `## Guess the Number with @${them}\n\n${display}\n\nTry again! Start a new game with \`vibe guessnumber @${them}\``;
+  } else {
+    return `## Guess the Number with @${them}\n\n${display}\n\nMake your next guess with \`vibe guessnumber @${them} --guess NUMBER\``;
+  }
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { handle, guess } = args;
+  const difficulty = args.difficulty || 'medium';
+  const myHandle = config.getHandle();
+  const them = normalizeHandle(handle);
+
+  if (them === myHandle) {
+    return { display: 'You can\'t play a guessing game with yourself! That would be cheating! 😄' };
+  }
+
+  // Get existing thread
+  const thread = await store.getThread(myHandle, them);
+  let gameState = getGameState(thread);
+
+  // Show current state if no guess provided
+  if (guess === undefined) {
+    if (!gameState) {
+      // Start new game
+      const newGameState = guessNumber.createInitialGuessNumberState(difficulty);
+      const payload = createGamePayload('guessnumber', newGameState);
+      
+      const difficultyInfo = guessNumber.getDifficultyInfo()[difficulty];
+      await store.sendMessage(
+        myHandle, 
+        them, 
+        `Started a new guess the number game! (${difficulty}: ${difficultyInfo.range}) I'm thinking of a number... can you guess it?`, 
+        'dm', 
+        payload
+      );
+
+      return {
+        display: `## New Guess the Number Game with @${them}\n\n${guessNumber.formatGuessNumberDisplay(newGameState)}\n\nUse \`vibe guessnumber @${them} --guess NUMBER\` to make your first guess!`
+      };
+    }
+
+    // Show existing game
+    return {
+      display: formatGameDisplay(gameState, them)
+    };
+  }
+
+  // Make a guess
+  // Initialize game if needed
+  if (!gameState) {
+    gameState = guessNumber.createInitialGuessNumberState(difficulty);
+  }
+
+  // Check if game is over
+  if (gameState.gameOver) {
+    return { display: `This game is over! Start a new game with \`vibe guessnumber @${them}\` (no guess).` };
+  }
+
+  // Make the guess
+  const result = guessNumber.makeGuess(gameState, guess);
+  if (result.error) {
+    return { display: `${result.error}` };
+  }
+
+  const newGameState = result.gameState;
+  const payload = createGamePayload('guessnumber', newGameState);
+
+  // Send message with game state
+  let message = '';
+  if (newGameState.won) {
+    message = `🎉 You got it! The number was ${newGameState.targetNumber}! Solved in ${newGameState.moves} guesses!`;
+    // Post to board
+    await postGameResult(myHandle, them, newGameState.moves, newGameState.difficulty);
+  } else {
+    message = `Guessed ${guess}. ${newGameState.lastHint} Keep trying!`;
+  }
+
+  await store.sendMessage(myHandle, them, message, 'dm', payload);
+
+  return {
+    display: formatGameDisplay(newGameState, them)
+  };
+}
+
+module.exports = { definition, handler };

package/tools/_deprecated/hangman.js

@@ -0,0 +1,129 @@
+/**
+ * vibe hangman — Play hangman word guessing game
+ *
+ * Single-player game where you guess letters to find the hidden word
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { createGamePayload } = require('../protocol');
+const { requireInit } = require('./_shared');
+
+// Hangman game implementation
+const hangman = require('../games/hangman');
+
+const definition = {
+  name: 'vibe_hangman',
+  description: 'Play hangman - guess letters to find the hidden word',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      guess: {
+        type: 'string',
+        description: 'Letter to guess (a-z) or "new" to start a new game'
+      },
+      difficulty: {
+        type: 'string',
+        description: 'Difficulty level for new games (easy, medium, hard)',
+        enum: ['easy', 'medium', 'hard']
+      }
+    },
+    required: []
+  }
+};
+
+/**
+ * Get latest hangman game state for user
+ */
+async function getLatestHangmanState(handle) {
+  // Get user's thread with themselves (for single-player games)
+  const thread = await store.getThread(handle, handle);
+  
+  // Find the most recent hangman game
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const msg = thread[i];
+    if (msg.payload?.type === 'game' && msg.payload?.game === 'hangman') {
+      return msg.payload.state;
+    }
+  }
+  return null;
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { guess, difficulty = 'medium' } = args;
+  const myHandle = config.getHandle();
+
+  // Get current game state
+  let gameState = await getLatestHangmanState(myHandle);
+
+  // Start new game
+  if (!gameState || guess === 'new' || (gameState.gameOver && !guess)) {
+    gameState = hangman.createInitialHangmanState(difficulty);
+    const payload = createGamePayload('hangman', gameState);
+
+    await store.sendMessage(myHandle, myHandle, `New ${difficulty} hangman game started!`, 'dm', payload);
+
+    const display = hangman.formatHangmanDisplay(gameState);
+    return {
+      display: `## New Hangman Game (${difficulty})\n\n${display}\n\nGuess letters with: \`vibe hangman --guess a\``
+    };
+  }
+
+  // Show current game if no guess
+  if (!guess) {
+    const display = hangman.formatHangmanDisplay(gameState);
+    const status = gameState.gameOver ? 
+      '\nGame over! Use `vibe hangman` with no arguments to start a new game.' :
+      '\nGuess letters with: `vibe hangman --guess a`';
+    
+    return {
+      display: `## Hangman Game\n\n${display}${status}`
+    };
+  }
+
+  // Make a guess
+  const result = hangman.makeGuess(gameState, guess);
+  
+  if (result.error) {
+    const display = hangman.formatHangmanDisplay(gameState);
+    return {
+      display: `## Hangman Game\n\n${display}\n\n❌ **${result.error}**\n\nTry again: \`vibe hangman --guess a\``
+    };
+  }
+
+  // Update game state
+  const newGameState = result.gameState;
+  const payload = createGamePayload('hangman', newGameState);
+
+  // Send message with updated state
+  let message = `Guessed "${guess.toUpperCase()}".`;
+  if (newGameState.gameOver) {
+    if (newGameState.won) {
+      message += ` 🎉 You won! The word was "${newGameState.word.toUpperCase()}".`;
+    } else {
+      message += ` 💀 Game over! The word was "${newGameState.word.toUpperCase()}".`;
+    }
+  } else {
+    if (newGameState.correctGuesses.includes(guess.toLowerCase())) {
+      message += ' Good guess! ✅';
+    } else {
+      message += ' Not in the word! ❌';
+    }
+  }
+
+  await store.sendMessage(myHandle, myHandle, message, 'dm', payload);
+
+  const display = hangman.formatHangmanDisplay(newGameState);
+  const status = newGameState.gameOver ?
+    '\n\n🎮 Use `vibe hangman` to start a new game!' :
+    '\n\nKeep guessing: `vibe hangman --guess e`';
+
+  return {
+    display: `## Hangman Game\n\n${display}${status}`
+  };
+}
+
+module.exports = { definition, handler };