slashvibe-mcp 0.2.2 → 0.2.3

package/tools/genesis.js

@@ -0,0 +1,233 @@
+/**
+ * vibe_genesis - Genesis liquidity mining
+ *
+ * Deposit USDC to earn yield + Genesis multipliers
+ *
+ * Actions:
+ * - deposit: Lock USDC for yield farming
+ * - rewards: Check accumulated rewards
+ * - stats: View global Genesis stats
+ *
+ * Examples:
+ * - "vibe genesis deposit $100 for 90 days"
+ * - "check my genesis rewards"
+ * - "show genesis stats"
+ */
+
+const fetch = require('node-fetch');
+
+module.exports = {
+  name: 'vibe_genesis',
+  description: 'Genesis liquidity mining: deposit USDC to earn yield with early depositor bonuses. Base APY 5%, Genesis multipliers up to 2x, lock bonuses up to 2x.',
+
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['deposit', 'rewards', 'stats'],
+        description: 'Action to perform: deposit (add liquidity), rewards (check earnings), stats (global metrics)'
+      },
+      amount: {
+        type: 'number',
+        description: 'Amount to deposit in USD (min $10). Only for deposit action.'
+      },
+      lock_days: {
+        type: 'number',
+        enum: [0, 30, 90, 180],
+        description: 'Lock period in days: 0 (no lock), 30 (+20% APY), 90 (+50% APY), 180 (+100% APY). Only for deposit action.',
+        default: 0
+      }
+    },
+    required: ['action']
+  },
+
+  async execute({ action, amount, lock_days = 0 }, context) {
+    try {
+      const handle = context.handle;
+
+      if (!handle) {
+        return {
+          success: false,
+          error: 'Not authenticated. Use vibe init first.'
+        };
+      }
+
+      const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+      switch (action) {
+        case 'deposit': {
+          if (!amount || amount < 10) {
+            return {
+              success: false,
+              error: 'Minimum deposit is $10'
+            };
+          }
+
+          const response = await fetch(`${apiUrl}/api/genesis/deposit`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': `Bearer ${context.token}`
+            },
+            body: JSON.stringify({
+              from: handle,
+              amount,
+              lock_days
+            })
+          });
+
+          const result = await response.json();
+
+          if (!response.ok) {
+            return {
+              success: false,
+              error: result.error || 'Deposit failed',
+              details: result.details
+            };
+          }
+
+          const effectiveAPY = result.effective_apy * 100;
+          const unlockDate = result.unlock_at
+            ? new Date(result.unlock_at).toLocaleDateString()
+            : 'No lock';
+
+          return {
+            success: true,
+            message: `Deposited $${amount} to Genesis mining`,
+            deposit: {
+              deposit_id: result.deposit_id,
+              amount: `$${amount}`,
+              base_apy: `${(result.base_apy * 100).toFixed(2)}%`,
+              genesis_multiplier: `${result.genesis_multiplier}x`,
+              effective_apy: `${effectiveAPY.toFixed(2)}%`,
+              lock_days,
+              unlock_at: unlockDate,
+              current_tvl: `$${result.current_tvl.toFixed(2)}`
+            },
+            formatted: `
+💧 Genesis Deposit Successful!
+
+Amount: $${amount}
+Lock Period: ${lock_days} days
+Unlock: ${unlockDate}
+
+APY Breakdown:
+  Base: ${(result.base_apy * 100).toFixed(2)}%
+  Genesis Multiplier: ${result.genesis_multiplier}x
+  Lock Bonus: ${lock_days >= 180 ? '2.0x' : lock_days >= 90 ? '1.5x' : lock_days >= 30 ? '1.2x' : '1.0x'}
+
+  Effective APY: ${effectiveAPY.toFixed(2)}%
+
+Current TVL: $${result.current_tvl.toFixed(2)}
+
+Rewards accrue daily. Check with: vibe genesis rewards
+            `.trim()
+          };
+        }
+
+        case 'rewards': {
+          const response = await fetch(
+            `${apiUrl}/api/genesis/rewards?handle=${handle}`,
+            {
+              headers: {
+                'Authorization': `Bearer ${context.token}`
+              }
+            }
+          );
+
+          const result = await response.json();
+
+          if (!response.ok) {
+            return {
+              success: false,
+              error: result.error || 'Failed to fetch rewards',
+              message: result.message
+            };
+          }
+
+          const deposits = result.deposits || [];
+          const totals = result.totals;
+
+          const depositLines = deposits.map(d => {
+            return `  $${d.amount.toFixed(2)} | ${d.days_deposited}d | ${(d.effective_apy * 100).toFixed(2)}% APY | +$${d.unclaimed_rewards.toFixed(2)} earned`;
+          });
+
+          return {
+            success: true,
+            rewards: totals,
+            deposits: deposits,
+            formatted: `
+💰 Genesis Rewards
+
+Total Deposited: $${totals.total_deposited.toFixed(2)}
+Unclaimed Rewards: $${totals.total_rewards.toFixed(2)}
+Total Value: $${totals.total_value.toFixed(2)}
+
+Active Deposits:
+${depositLines.length > 0 ? depositLines.join('\n') : '  No active deposits'}
+
+Rewards accrue daily based on your effective APY.
+            `.trim()
+          };
+        }
+
+        case 'stats': {
+          const response = await fetch(`${apiUrl}/api/genesis/stats`);
+          const result = await response.json();
+
+          if (!response.ok) {
+            return {
+              success: false,
+              error: 'Failed to fetch stats'
+            };
+          }
+
+          const tierLines = result.multiplier_tiers?.map(t => {
+            const marker = t.status === 'current' ? '→' : t.status === 'passed' ? '✓' : ' ';
+            return `  ${marker} ${t.tvl_range.padEnd(12)} ${t.multiplier}x ${t.status}`;
+          }) || [];
+
+          return {
+            success: true,
+            stats: result,
+            formatted: `
+🌊 Genesis Liquidity Mining Stats
+
+Phase: ${result.genesis_phase} (${result.genesis_progress}% to goal)
+Total Value Locked: $${result.tvl.toFixed(2)}
+Depositors: ${result.total_depositors}
+Avg Deposit: $${result.avg_deposit.toFixed(2)}
+
+Current Multiplier: ${result.current_multiplier}x
+Base APY: ${(result.base_apy * 100).toFixed(2)}%
+
+Multiplier Tiers:
+${tierLines.join('\n')}
+
+Rewards Distributed: $${result.total_rewards_distributed.toFixed(2)}
+
+Top Depositors:
+${result.top_depositors?.slice(0, 5).map((d, i) =>
+  `  ${i + 1}. ${d.handle} - $${d.total_deposited.toFixed(2)}`
+).join('\n') || '  No depositors yet'}
+            `.trim()
+          };
+        }
+
+        default:
+          return {
+            success: false,
+            error: 'Invalid action. Use: deposit, rewards, or stats'
+          };
+      }
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Genesis action failed',
+        details: error.message
+      };
+    }
+  }
+};

package/tools/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/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 };