slashvibe-mcp 0.2.2 → 0.2.4

package/tools/tictactoe.js

@@ -0,0 +1,155 @@
+/**
+ * Tic-Tac-Toe tool - Play against AI with different difficulty levels
+ * 
+ * Usage:
+ * vibe tictactoe --difficulty easy (start new game)
+ * vibe tictactoe --move 5 (make move)
+ * vibe tictactoe (show current game)
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { 
+  createInitialTicTacToeState, 
+  makeMove, 
+  makeAIMove, 
+  formatTicTacToeDisplay,
+  getDifficultyDescription
+} = require('../games/tictactoe');
+const { requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_tictactoe',
+  description: 'Play tic-tac-toe against AI with different difficulty levels (easy, medium, hard)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      difficulty: {
+        type: 'string',
+        description: 'AI difficulty level',
+        enum: ['easy', 'medium', 'hard']
+      },
+      move: {
+        type: 'number',
+        description: 'Position to play (1-9)',
+        minimum: 1,
+        maximum: 9
+      },
+      reset: {
+        type: 'boolean',
+        description: 'Reset/start new game'
+      }
+    },
+    required: []
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { difficulty, move, reset } = args;
+  const myHandle = config.getHandle();
+  
+  // Get or create game state from memory
+  let gameState = await store.getMemory(myHandle, 'tictactoe_game');
+  
+  // Start new game if requested, no game exists, or game is over
+  if (reset || !gameState || gameState.gameOver) {
+    const newDifficulty = difficulty || 'medium';
+    gameState = createInitialTicTacToeState(newDifficulty);
+    await store.setMemory(myHandle, 'tictactoe_game', gameState);
+    
+    return {
+      display: `🎯 **New Tic-Tac-Toe Game Started!**\n\n${getDifficultyDescription(newDifficulty)}\n\n${formatTicTacToeDisplay(gameState)}\n\n💡 Use \`vibe tictactoe --move N\` to play position 1-9`
+    };
+  }
+  
+  // Show current game if no move specified
+  if (move === undefined) {
+    let display = `🎯 **Current Tic-Tac-Toe Game**\n\n${formatTicTacToeDisplay(gameState)}`;
+    
+    if (gameState.gameOver) {
+      display += `\n\n💡 Use \`vibe tictactoe --reset\` to start a new game`;
+      display += `\n💡 Use \`vibe tictactoe --difficulty hard\` to start with different difficulty`;
+    } else {
+      display += `\n\n💡 Use \`vibe tictactoe --move N\` to play position 1-9`;
+    }
+    
+    return { display };
+  }
+  
+  // Check if game is over
+  if (gameState.gameOver) {
+    return {
+      display: `🎯 **Game Over!**\n\n${formatTicTacToeDisplay(gameState)}\n\n💡 Use \`vibe tictactoe --reset\` to start a new game`
+    };
+  }
+  
+  // Check if it's player's turn
+  if (gameState.turn !== gameState.playerSymbol) {
+    return {
+      display: `⏳ **Not your turn!**\n\n${formatTicTacToeDisplay(gameState)}\n\nWait for AI to move.`
+    };
+  }
+  
+  // Make player move
+  const playerMoveResult = makeMove(gameState, move, gameState.playerSymbol);
+  
+  if (playerMoveResult.error) {
+    return {
+      display: `❌ **Invalid move:** ${playerMoveResult.error}\n\n${formatTicTacToeDisplay(gameState)}\n\n💡 Choose an empty position (1-9)`
+    };
+  }
+  
+  gameState = playerMoveResult.gameState;
+  
+  // Check if game ended after player move
+  if (gameState.gameOver) {
+    await store.setMemory(myHandle, 'tictactoe_game', gameState);
+    
+    let endMessage = '';
+    if (gameState.winner === gameState.playerSymbol) {
+      endMessage = `🎉 **Congratulations! You won!**`;
+    } else if (gameState.isDraw) {
+      endMessage = `🤝 **It's a draw!** Well played!`;
+    }
+    
+    return {
+      display: `${endMessage}\n\n${formatTicTacToeDisplay(gameState)}\n\n💡 Use \`vibe tictactoe --reset\` to start a new game`
+    };
+  }
+  
+  // Make AI move
+  const aiMoveResult = makeAIMove(gameState);
+  
+  if (aiMoveResult.error) {
+    return {
+      display: `🤖 **AI Error:** ${aiMoveResult.error}\n\n${formatTicTacToeDisplay(gameState)}`
+    };
+  }
+  
+  gameState = aiMoveResult.gameState;
+  
+  // Save game state
+  await store.setMemory(myHandle, 'tictactoe_game', gameState);
+  
+  // Check if game ended after AI move
+  let endMessage = '';
+  if (gameState.gameOver) {
+    if (gameState.winner === gameState.aiSymbol) {
+      endMessage = `🤖 **AI wins!** Try again!\n\n`;
+    } else if (gameState.isDraw) {
+      endMessage = `🤝 **It's a draw!** Good game!\n\n`;
+    }
+    endMessage += `💡 Use \`vibe tictactoe --reset\` to start a new game`;
+  } else {
+    endMessage = `💡 Your turn! Use \`vibe tictactoe --move N\` to play position 1-9`;
+  }
+  
+  return {
+    display: `🎯 **Move Complete**\n\n${formatTicTacToeDisplay(gameState)}\n\n${endMessage}`
+  };
+}
+
+module.exports = { definition, handler };

package/tools/tip.js

@@ -0,0 +1,120 @@
+/**
+ * vibe_tip - Send a tip to another user
+ *
+ * Makes the entire payment layer accessible from Claude Code conversations
+ *
+ * Examples:
+ * - "tip @alice $5 for helping debug"
+ * - "send @bob $10 thanks for the intro"
+ * - "vibe tip @charlie 2.50"
+ */
+
+const fetch = require('node-fetch');
+
+module.exports = {
+  name: 'vibe_tip',
+  description: 'Send a tip to another user. Tips are instant payments via blockchain (2.5% fee). Example: vibe_tip @alice 5 "thanks for the help!"',
+
+  inputSchema: {
+    type: 'object',
+    properties: {
+      to: {
+        type: 'string',
+        description: 'Recipient handle (e.g., @alice)'
+      },
+      amount: {
+        type: 'number',
+        description: 'Amount in USD (e.g., 5.00). Min $0.01, Max $100'
+      },
+      message: {
+        type: 'string',
+        description: 'Optional message to include with the tip'
+      }
+    },
+    required: ['to', 'amount']
+  },
+
+  async execute({ to, amount, message }, context) {
+    try {
+      const from = context.handle;
+
+      if (!from) {
+        return {
+          success: false,
+          error: 'Not authenticated. Use vibe init first.'
+        };
+      }
+
+      // Validate amount
+      if (amount <= 0 || amount > 100) {
+        return {
+          success: false,
+          error: 'Amount must be between $0.01 and $100'
+        };
+      }
+
+      // Call payment API
+      const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+      const response = await fetch(`${apiUrl}/api/payments/tip`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${context.token}`
+        },
+        body: JSON.stringify({
+          from,
+          to,
+          amount,
+          message
+        })
+      });
+
+      const result = await response.json();
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: result.error || 'Tip failed',
+          details: result.details
+        };
+      }
+
+      // Format success message
+      const fee = result.fee || (amount * 0.025);
+      const net = amount - fee;
+
+      return {
+        success: true,
+        message: `💰 Tipped ${to} $${amount}`,
+        details: {
+          recipient: to,
+          amount: `$${amount}`,
+          fee: `$${fee.toFixed(2)} (2.5%)`,
+          net_to_recipient: `$${net.toFixed(2)}`,
+          tx_hash: result.tx_hash,
+          status: result.status,
+          explorer_url: `https://sepolia.basescan.org/tx/${result.tx_hash}`
+        },
+        formatted: `
+✓ Tip sent!
+  To: ${to}
+  Amount: $${amount}
+  Fee: $${fee.toFixed(2)}
+  Net: $${net.toFixed(2)}
+  ${message ? `Message: "${message}"` : ''}
+
+  Tx: ${result.tx_hash?.substring(0, 10)}...
+  Status: ${result.status}
+        `.trim()
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Tip failed',
+        details: error.message
+      };
+    }
+  }
+};

package/tools/token.js

@@ -0,0 +1,103 @@
+/**
+ * vibe token — Set Privy auth token after browser OAuth
+ *
+ * Usage:
+ *   vibe token <paste-token-here>
+ *
+ * After authenticating via GitHub in browser, paste the token here
+ * to complete authentication.
+ */
+
+const config = require('../config');
+const store = require('../store');
+
+const definition = {
+  name: 'vibe_token',
+  description: 'Set your auth token after browser authentication. Use after completing GitHub OAuth in browser.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      token: {
+        type: 'string',
+        description: 'The auth token from browser authentication'
+      }
+    },
+    required: ['token']
+  }
+};
+
+async function handler(args) {
+  const { token } = args;
+
+  if (!token || token.trim().length < 10) {
+    return {
+      display: `❌ **Invalid token**
+
+Please paste the full token from your browser authentication.
+
+If you haven't authenticated yet:
+1. Run \`vibe init @yourhandle\` to start
+2. Open the auth URL in your browser
+3. Complete GitHub authentication
+4. Paste the token here`
+    };
+  }
+
+  // Verify token with server
+  const verification = await store.verifyPrivyToken(token.trim());
+
+  if (!verification.valid) {
+    return {
+      display: `❌ **Token verification failed**
+
+Error: ${verification.error}
+
+The token may be expired or invalid. Try authenticating again:
+1. Visit: ${config.getApiUrl()}/api/auth/github?handle=${config.getHandle() || 'yourhandle'}
+2. Complete GitHub authentication
+3. Paste the new token here`
+    };
+  }
+
+  // Save token
+  config.savePrivyToken(token.trim());
+
+  // Update session identity with verified handle
+  const handle = verification.handle;
+  const oneLiner = config.getOneLiner() || 'Building something';
+  config.setSessionIdentity(handle, oneLiner);
+
+  // Update shared config
+  const cfg = config.load();
+  cfg.handle = handle;
+  cfg.one_liner = oneLiner;
+  config.save(cfg);
+
+  // Remove old keypair (security improvement)
+  if (config.hasKeypair()) {
+    config.removeKeypair();
+  }
+
+  // Send initial heartbeat
+  await store.heartbeat(handle, oneLiner);
+
+  return {
+    display: `✅ **Authenticated as @${handle}**
+
+GitHub: @${verification.github || 'linked'}
+Expires: ${verification.expiresAt ? new Date(verification.expiresAt * 1000).toLocaleString() : 'unknown'}
+
+Your messages are now signed server-side (more secure).
+${config.hasKeypair() ? '' : '🔒 Old local keys have been removed.'}
+
+You're ready to vibe! Try:
+• \`vibe who\` — See who's online
+• \`vibe inbox\` — Check messages
+• \`vibe dm @someone "hello"\` — Send a message`,
+    handle,
+    github: verification.github,
+    authMethod: 'privy'
+  };
+}
+
+module.exports = { definition, handler };

package/tools/twentyquestions.js

@@ -0,0 +1,143 @@
+/**
+ * vibe twenty-questions — Play 20 questions guessing game
+ *
+ * I think of something, you ask yes/no questions to guess what it is!
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { createGamePayload } = require('../protocol');
+const { requireInit } = require('./_shared');
+
+// 20 Questions game implementation
+const twentyQuestions = require('../games/twentyquestions');
+
+const definition = {
+  name: 'vibe_twenty_questions',
+  description: 'Play 20 questions - I think of something, you guess it with yes/no questions',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      question: {
+        type: 'string',
+        description: 'Yes/no question to ask, or "new" to start a new game'
+      },
+      category: {
+        type: 'string',
+        description: 'Category for new games (animals, objects, food, places, activities)',
+        enum: ['animals', 'objects', 'food', 'places', 'activities']
+      }
+    },
+    required: []
+  }
+};
+
+/**
+ * Get latest 20 questions game state for user
+ */
+async function getLatestTwentyQuestionsState(handle) {
+  // Get user's thread with themselves (for single-player games)
+  const thread = await store.getThread(handle, handle);
+  
+  // Find the most recent 20 questions game
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const msg = thread[i];
+    if (msg.payload?.type === 'game' && msg.payload?.game === 'twentyquestions') {
+      return msg.payload.state;
+    }
+  }
+  return null;
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { question, category } = args;
+  const myHandle = config.getHandle();
+
+  // Get current game state
+  let gameState = await getLatestTwentyQuestionsState(myHandle);
+
+  // Start new game
+  if (!gameState || question === 'new' || (gameState.gameOver && !question)) {
+    gameState = twentyQuestions.createInitialTwentyQuestionsState('guess', null, category);
+    const payload = createGamePayload('twentyquestions', gameState);
+
+    const categoryText = category ? ` (${category} category)` : '';
+    await store.sendMessage(myHandle, myHandle, `New 20 questions game started${categoryText}! I'm thinking of something...`, 'dm', payload);
+
+    const display = twentyQuestions.formatTwentyQuestionsDisplay(gameState);
+    return {
+      display: `## New 20 Questions Game\n\n${display}\n\nAsk yes/no questions: \`vibe twenty-questions --question "Is it alive?"\``
+    };
+  }
+
+  // Show current game if no question
+  if (!question) {
+    const display = twentyQuestions.formatTwentyQuestionsDisplay(gameState);
+    const status = gameState.gameOver ? 
+      '\nGame over! Use `vibe twenty-questions` to start a new game.' :
+      '\nAsk a question: `vibe twenty-questions --question "Is it big?"`';
+    
+    return {
+      display: `## 20 Questions Game\n\n${display}${status}`
+    };
+  }
+
+  // Process question or guess
+  let result;
+  
+  // Check if it's a guess (starts with "is it" or "it is")
+  const normalizedQuestion = question.toLowerCase().trim();
+  if (normalizedQuestion.startsWith('is it ') || normalizedQuestion.startsWith('it is ')) {
+    const guess = normalizedQuestion.startsWith('is it ') ? 
+      normalizedQuestion.substring(6) : normalizedQuestion.substring(6);
+    result = twentyQuestions.processGuess(gameState, guess);
+  } else {
+    result = twentyQuestions.askQuestion(gameState, question);
+  }
+  
+  if (result.error) {
+    const display = twentyQuestions.formatTwentyQuestionsDisplay(gameState);
+    return {
+      display: `## 20 Questions Game\n\n${display}\n\n❌ **${result.error}**\n\nTry again: \`vibe twenty-questions --question "Is it alive?"\``
+    };
+  }
+
+  // Update game state
+  const newGameState = result.gameState;
+  const payload = createGamePayload('twentyquestions', newGameState);
+
+  // Send message with updated state
+  let message;
+  if (newGameState.gameOver) {
+    if (newGameState.won) {
+      message = `🎉 Correct! It was "${newGameState.item}"! You guessed it in ${newGameState.moves} questions!`;
+    } else {
+      message = `💀 Sorry! It was "${newGameState.item}". Better luck next time!`;
+    }
+  } else if (newGameState.currentQuestion) {
+    const { answer } = newGameState.currentQuestion;
+    message = `Question ${newGameState.moves}: "${question}" → **${answer.toUpperCase()}**`;
+  } else if (newGameState.message) {
+    message = newGameState.message;
+  } else {
+    message = 'Question processed!';
+  }
+
+  await store.sendMessage(myHandle, myHandle, message, 'dm', payload);
+
+  const display = twentyQuestions.formatTwentyQuestionsDisplay(newGameState);
+  const status = newGameState.gameOver ?
+    '\n\n🎮 Use `vibe twenty-questions` to start a new game!' :
+    newGameState.questionsLeft === 0 ?
+    '\n\nNo questions left! Make your final guess: `vibe twenty-questions --question "Is it a cat?"`' :
+    '\n\nNext question: `vibe twenty-questions --question "Does it fly?"`';
+
+  return {
+    display: `## 20 Questions Game\n\n${display}${status}`
+  };
+}
+
+module.exports = { definition, handler };

package/tools/update.js

@@ -49,7 +49,7 @@ async function handler(args) {
     display += `Your install doesn't support automatic updates.\n\n`;
     display += `To update, re-run the installer:\n`;
     display += `\`\`\`\n`;
-    display += `curl -fsSL https://raw.githubusercontent.com/brightseth/vibe/main/install.sh | bash\n`;
+    display += `curl -fsSL https://raw.githubusercontent.com/VibeCodingInc/vibe-mcp/main/install.sh | bash\n`;
     display += `\`\`\`\n\n`;
     display += `This will migrate you to the git-based installer for future updates.\n\n`;
     display += `---\n`;

package/tools/wallet.js

@@ -0,0 +1,127 @@
+/**
+ * vibe_wallet - Check wallet balance and transaction history
+ *
+ * View your economic state: balance, recent transactions, earnings
+ *
+ * Examples:
+ * - "vibe wallet"
+ * - "check my balance"
+ * - "show recent transactions"
+ */
+
+const fetch = require('node-fetch');
+
+module.exports = {
+  name: 'vibe_wallet',
+  description: 'Check your wallet balance and recent transactions. Shows tips sent/received, escrows, and current balance.',
+
+  inputSchema: {
+    type: 'object',
+    properties: {
+      limit: {
+        type: 'number',
+        description: 'Number of recent transactions to show (default 10, max 50)',
+        default: 10
+      },
+      show_balance: {
+        type: 'boolean',
+        description: 'Show current balance (default true)',
+        default: true
+      }
+    }
+  },
+
+  async execute({ limit = 10, show_balance = true }, 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';
+
+      // Fetch transaction history
+      const historyResponse = await fetch(
+        `${apiUrl}/api/payments/history?handle=${handle}&limit=${Math.min(limit, 50)}`,
+        {
+          headers: {
+            'Authorization': `Bearer ${context.token}`
+          }
+        }
+      );
+
+      const historyResult = await historyResponse.json();
+
+      if (!historyResponse.ok) {
+        return {
+          success: false,
+          error: 'Failed to fetch wallet data',
+          details: historyResult.error
+        };
+      }
+
+      const transactions = historyResult.transactions || [];
+
+      // Calculate balance from transactions (simplified)
+      let balance = 0;
+      let totalReceived = 0;
+      let totalSent = 0;
+
+      transactions.forEach(tx => {
+        if (tx.type?.includes('received') || tx.type === 'escrow_completed') {
+          totalReceived += tx.amount || 0;
+        } else if (tx.type?.includes('sent') || tx.type === 'escrow_created') {
+          totalSent += tx.amount || 0;
+        }
+      });
+
+      balance = totalReceived - totalSent;
+
+      // Format transactions
+      const formattedTxs = transactions.slice(0, limit).map(tx => {
+        const isReceived = tx.type?.includes('received') || tx.type === 'escrow_completed';
+        const icon = isReceived ? '↓' : '↑';
+        const peer = isReceived ? tx.from : tx.to;
+        const amountStr = isReceived
+          ? `+$${tx.amount?.toFixed(2) || '0.00'}`
+          : `-$${tx.amount?.toFixed(2) || '0.00'}`;
+
+        return `${icon} ${amountStr.padEnd(10)} ${peer || 'unknown'} (${tx.status})`;
+      });
+
+      return {
+        success: true,
+        wallet: {
+          handle,
+          balance: `$${balance.toFixed(2)}`,
+          total_received: `$${totalReceived.toFixed(2)}`,
+          total_sent: `$${totalSent.toFixed(2)}`,
+          transaction_count: transactions.length
+        },
+        formatted: `
+💰 Wallet: ${handle}
+
+Balance: $${balance.toFixed(2)}
+  Received: $${totalReceived.toFixed(2)}
+  Sent: $${totalSent.toFixed(2)}
+
+Recent Transactions (${Math.min(limit, transactions.length)}):
+${formattedTxs.length > 0 ? formattedTxs.join('\n') : '  No transactions yet'}
+
+${historyResult.has_more ? `\n(${transactions.length - limit} more transactions...)` : ''}
+        `.trim()
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Failed to fetch wallet',
+        details: error.message
+      };
+    }
+  }
+};