slashvibe-mcp 0.2.9 → 0.3.13

package/tools/_deprecated/multiplayer-tictactoe.js

@@ -0,0 +1,303 @@
+/**
+ * Multiplayer Tic-Tac-Toe — Create or join room-based tic-tac-toe games
+ * 
+ * Room-based system where players can create/join games and play together.
+ * Multiple rooms can run simultaneously with spectators allowed!
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+const multiTicTacToe = require('../games/multiplayer-tictactoe');
+
+const definition = {
+  name: 'vibe_multiplayer_tictactoe',
+  description: 'Create or join multiplayer tic-tac-toe game rooms. Play with friends and allow spectators!',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      room: {
+        type: 'string',
+        description: 'Room name (creates if doesn\'t exist, e.g., "quick-game", "tournament-finals")'
+      },
+      action: {
+        type: 'string',
+        description: 'Action to take',
+        enum: ['view', 'join', 'spectate', 'move', 'leave', 'restart', 'list']
+      },
+      position: {
+        type: 'number',
+        description: 'Position to play (1-9)',
+        minimum: 1,
+        maximum: 9
+      }
+    },
+    required: ['room']
+  }
+};
+
+// Storage key for multiplayer tic-tac-toe rooms
+function getRoomKey(roomName) {
+  return `multiplayer_tictactoe:${roomName.toLowerCase()}`;
+}
+
+// Get or create game room
+async function getOrCreateRoom(roomName, hostHandle) {
+  const key = getRoomKey(roomName);
+  
+  try {
+    const existing = await store.kv.get(key);
+    if (existing) {
+      return JSON.parse(existing);
+    }
+  } catch (e) {
+    console.log(`[multiplayer-tictactoe] Creating new room: ${roomName}`);
+  }
+  
+  // Create new room
+  const newRoom = multiTicTacToe.createInitialMultiplayerTicTacToeState(hostHandle, roomName);
+  await store.kv.set(key, JSON.stringify(newRoom));
+  return newRoom;
+}
+
+// Save room state
+async function saveRoom(roomName, gameState) {
+  const key = getRoomKey(roomName);
+  await store.kv.set(key, JSON.stringify(gameState));
+}
+
+// List all active rooms
+async function listActiveRooms() {
+  try {
+    // In a real implementation, we'd query the KV store for all multiplayer_tictactoe:* keys
+    // For now, return empty array since we can't easily list KV keys
+    return [];
+  } catch (e) {
+    console.error('[multiplayer-tictactoe] Error listing rooms:', e.message);
+    return [];
+  }
+}
+
+// Post game activity to board
+async function postGameActivity(roomName, playerHandle, action, details = '') {
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+  
+  try {
+    let content = '';
+    switch (action) {
+      case 'created':
+        content = `🎯 @${playerHandle} created tic-tac-toe room "${roomName}" — join the game!`;
+        break;
+      case 'joined':
+        content = `🎯 @${playerHandle} joined tic-tac-toe room "${roomName}"`;
+        break;
+      case 'started':
+        content = `🎯 Tic-tac-toe game started in room "${roomName}" — spectators welcome!`;
+        break;
+      case 'won':
+        content = `🎉 @${playerHandle} won the tic-tac-toe game in "${roomName}"!`;
+        break;
+      case 'draw':
+        content = `🤝 Tic-tac-toe game in "${roomName}" ended in a draw!`;
+        break;
+      default:
+        return; // Don't post for other actions
+    }
+
+    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('[multiplayer-tictactoe] Failed to post to board:', e.message);
+  }
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { room, action = 'view', position } = args;
+  const myHandle = config.getHandle();
+  
+  // List all active rooms
+  if (action === 'list') {
+    const rooms = await listActiveRooms();
+    
+    if (rooms.length === 0) {
+      return {
+        display: `## 🎯 Multiplayer Tic-Tac-Toe Rooms\n\nNo active rooms found.\n\nCreate one: \`vibe multiplayer-tictactoe --room "my-game" --action join\``
+      };
+    }
+    
+    let display = `## 🎯 Active Multiplayer Tic-Tac-Toe Rooms\n\n`;
+    
+    for (const roomData of rooms) {
+      const gameState = roomData.state;
+      const players = gameState.players || [];
+      const spectators = gameState.spectators || [];
+      const status = gameState.gameOver ? '✅ Complete' : 
+                     gameState.gameStarted ? '🎲 In Progress' : 
+                     `🏁 Waiting (${players.length}/2 players)`;
+      
+      display += `**${roomData.name}** - ${status}\n`;
+      display += `  Host: @${gameState.host}\n`;
+      display += `  Players: ${players.map(p => `@${p}`).join(', ') || 'None'}\n`;
+      if (spectators.length > 0) {
+        display += `  Spectators: ${spectators.map(s => `@${s}`).join(', ')}\n`;
+      }
+      display += `  Join: \`vibe multiplayer-tictactoe --room "${roomData.name}" --action join\`\n\n`;
+    }
+    
+    return { display };
+  }
+  
+  if (!room) {
+    return { display: 'Room name is required. Use something like "quick-game" or "tournament-finals"' };
+  }
+
+  // Normalize room name
+  const roomName = room.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+  
+  try {
+    // Get or create room
+    let gameState = await getOrCreateRoom(roomName, myHandle);
+    let wasNewRoom = gameState.players.length === 0 && gameState.spectators.length === 0;
+    let wasWaitingForPlayers = !gameState.gameStarted && gameState.players.length < 2;
+    
+    // Handle different actions
+    switch (action) {
+      case 'view':
+        // Just show current state
+        break;
+        
+      case 'join':
+        const joinResult = multiTicTacToe.joinRoom(gameState, myHandle, false);
+        if (joinResult.error) {
+          return { display: joinResult.error };
+        }
+        
+        gameState = joinResult.gameState;
+        await saveRoom(roomName, gameState);
+        
+        // Post activity based on what happened
+        if (wasNewRoom) {
+          await postGameActivity(roomName, myHandle, 'created');
+        } else if (wasWaitingForPlayers) {
+          await postGameActivity(roomName, myHandle, 'joined');
+        }
+        
+        // If game just started, announce it
+        if (gameState.gameStarted && wasWaitingForPlayers) {
+          await postGameActivity(roomName, null, 'started');
+        }
+        break;
+        
+      case 'spectate':
+        const spectateResult = multiTicTacToe.joinRoom(gameState, myHandle, true);
+        if (spectateResult.error) {
+          return { display: spectateResult.error };
+        }
+        
+        gameState = spectateResult.gameState;
+        await saveRoom(roomName, gameState);
+        break;
+        
+      case 'move':
+        if (position === undefined) {
+          return { display: 'Move action requires position. Example: `--action move --position 5`' };
+        }
+        
+        const moveResult = multiTicTacToe.makeMove(gameState, position, myHandle);
+        if (moveResult.error) {
+          return { display: moveResult.error };
+        }
+        
+        const prevGameState = gameState;
+        gameState = moveResult.gameState;
+        await saveRoom(roomName, gameState);
+        
+        // Post result if game ended
+        if (gameState.gameOver && !prevGameState.gameOver) {
+          if (gameState.winner) {
+            const winnerHandle = Object.keys(gameState.playerSymbols).find(h => gameState.playerSymbols[h] === gameState.winner);
+            await postGameActivity(roomName, winnerHandle, 'won');
+          } else if (gameState.isDraw) {
+            await postGameActivity(roomName, null, 'draw');
+          }
+        }
+        break;
+        
+      case 'leave':
+        const leaveResult = multiTicTacToe.leaveRoom(gameState, myHandle);
+        if (leaveResult.error) {
+          return { display: leaveResult.error };
+        }
+        
+        gameState = leaveResult.gameState;
+        await saveRoom(roomName, gameState);
+        
+        return {
+          display: `✅ Left room "${roomName}". ${gameState.gameOver ? 'Game ended due to forfeit.' : ''}`
+        };
+        
+      case 'restart':
+        const restartResult = multiTicTacToe.restartGame(gameState, myHandle);
+        if (restartResult.error) {
+          return { display: restartResult.error };
+        }
+        
+        gameState = restartResult.gameState;
+        await saveRoom(roomName, gameState);
+        break;
+        
+      default:
+        return { display: `Unknown action "${action}". Use: view, join, spectate, move, leave, restart, or list` };
+    }
+    
+    // Format and return display
+    const display = multiTicTacToe.formatMultiplayerTicTacToeDisplay(gameState, myHandle);
+    let result = `# 🎯 Multiplayer Tic-Tac-Toe Room: "${roomName}"\n\n${display}`;
+    
+    // Add usage instructions based on game state
+    if (!gameState.gameStarted) {
+      result += '\n**How to play:**\n';
+      if (gameState.players.length < 2) {
+        result += `• \`vibe multiplayer-tictactoe --room "${roomName}" --action join\` - Join as player\n`;
+      }
+      result += `• \`vibe multiplayer-tictactoe --room "${roomName}" --action spectate\` - Watch the game\n`;
+    } else if (!gameState.gameOver) {
+      result += '\n**Game commands:**\n';
+      result += `• \`vibe multiplayer-tictactoe --room "${roomName}" --action move --position N\` - Play position 1-9\n`;
+      result += `• \`vibe multiplayer-tictactoe --room "${roomName}" --action leave\` - Leave game\n`;
+    } else {
+      result += '\n**Game over!**\n';
+      result += `• \`vibe multiplayer-tictactoe --room "${roomName}" --action restart\` - Play again (players only)\n`;
+      result += `• \`vibe multiplayer-tictactoe --room "${roomName}" --action leave\` - Leave room\n`;
+    }
+    
+    // Add room sharing info
+    result += `\n**Share this room:** \`vibe multiplayer-tictactoe --room "${roomName}"\`\n`;
+    
+    // Show available positions if game is active
+    if (gameState.gameStarted && !gameState.gameOver) {
+      const available = multiTicTacToe.getAvailablePositions(gameState);
+      if (available.length > 0) {
+        result += `**Available positions:** ${available.join(', ')}\n`;
+      }
+    }
+    
+    return { display: result };
+    
+  } catch (error) {
+    console.error('[multiplayer-tictactoe] Error:', error);
+    return { display: `Error: ${error.message}` };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/_deprecated/recall.js

@@ -0,0 +1,147 @@
+/**
+ * vibe recall — Query thread memories
+ *
+ * Shows observations saved about a specific thread.
+ * Local, inspectable, searchable.
+ *
+ * Usage:
+ *   vibe recall @handle      — Show memories about @handle
+ *   vibe recall              — Show all threads with memories
+ */
+
+const config = require('../config');
+const memory = require('../memory');
+
+const definition = {
+  name: 'vibe_recall',
+  description: 'Query thread memories. Shows saved observations about a person or lists all threads.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Who to recall memories about (e.g., @alex). If omitted, lists all threads.'
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum memories to show (default: 10)'
+      },
+      search: {
+        type: 'string',
+        description: 'Optional search term to filter memories'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  let { handle, limit = 10, search } = args;
+
+  // If no handle, list all threads
+  if (!handle) {
+    const threads = memory.listThreads();
+
+    if (threads.length === 0) {
+      let output = `## Memory — Empty\n\n`;
+      output += `_No memories saved yet._\n\n`;
+      output += `Save one with: \`vibe remember @handle "observation"\`\n`;
+      output += `Memories are stored locally: \`${memory.getMemoryPath()}/\``;
+      return { display: output };
+    }
+
+    let output = `## Memory — ${threads.length} ${threads.length === 1 ? 'Thread' : 'Threads'}\n\n`;
+
+    for (const thread of threads) {
+      const age = formatAge(thread.newestMemory);
+      output += `**@${thread.handle}** — ${thread.count} ${thread.count === 1 ? 'memory' : 'memories'} (${age})\n`;
+    }
+
+    output += `\n---\n`;
+    output += `_View a thread: \`vibe recall @handle\`_\n`;
+    output += `_Storage: \`${memory.getMemoryPath()}/\`_`;
+
+    return { display: output };
+  }
+
+  // Clean handle
+  handle = handle.replace(/^@/, '').toLowerCase();
+
+  // Get memories for this thread
+  let memories = memory.recall(handle, limit);
+
+  if (memories.length === 0) {
+    let output = `## Memory — @${handle}\n\n`;
+    output += `_No memories saved about @${handle}._\n\n`;
+    output += `Save one with: \`vibe remember @${handle} "observation"\``;
+    return { display: output };
+  }
+
+  // Apply search filter if provided
+  if (search) {
+    const searchLower = search.toLowerCase();
+    memories = memories.filter(m =>
+      m.observation.toLowerCase().includes(searchLower)
+    );
+
+    if (memories.length === 0) {
+      return {
+        display: `## Memory — @${handle}\n\n_No memories matching "${search}"._`
+      };
+    }
+  }
+
+  // Format output
+  let output = `## Memory — @${handle}\n\n`;
+
+  for (const m of memories) {
+    const age = formatAge(m.timestamp);
+    output += `• "${m.observation}" — _${age}_\n`;
+  }
+
+  const total = memory.count(handle);
+  if (total > memories.length) {
+    output += `\n_Showing ${memories.length} of ${total}. Use \`limit\` for more._\n`;
+  }
+
+  output += `\n---\n`;
+  output += `_Add: \`vibe remember @${handle} "..."\`_\n`;
+  output += `_Delete: \`vibe forget @${handle}\`_\n`;
+  output += `_File: \`${memory.getThreadFile(handle)}\`_`;
+
+  return { display: output };
+}
+
+/**
+ * Format a timestamp as relative age
+ */
+function formatAge(timestamp) {
+  if (!timestamp) return 'unknown';
+
+  const now = Date.now();
+  const then = new Date(timestamp).getTime();
+
+  if (isNaN(then)) return 'unknown';
+
+  const diff = now - then;
+
+  const minutes = Math.floor(diff / (1000 * 60));
+  const hours = Math.floor(diff / (1000 * 60 * 60));
+  const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+
+  if (minutes < 1) return 'just now';
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  if (days === 1) return 'yesterday';
+  if (days < 7) return `${days}d ago`;
+  if (days < 30) return `${Math.floor(days / 7)}w ago`;
+
+  return new Date(timestamp).toLocaleDateString();
+}
+
+module.exports = { definition, handler };

package/tools/_deprecated/remember.js

@@ -0,0 +1,86 @@
+/**
+ * vibe remember — Save observation to thread memory
+ *
+ * Memory is a promotion, not a capture.
+ * Explicit consent. Thread-scoped. Append-only.
+ *
+ * Usage:
+ *   vibe remember @handle "Solienne prefers center opening"
+ *   vibe remember "We discussed OAuth implementation" (uses last DM thread)
+ */
+
+const config = require('../config');
+const memory = require('../memory');
+const store = require('../store');
+
+const definition = {
+  name: 'vibe_remember',
+  description: 'Save an observation to thread memory. Explicit, local, inspectable.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      observation: {
+        type: 'string',
+        description: 'The observation to remember (required)'
+      },
+      handle: {
+        type: 'string',
+        description: 'Who this memory is about (e.g., @alex). If omitted, uses last active thread.'
+      }
+    },
+    required: ['observation']
+  }
+};
+
+async function handler(args) {
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  const { observation } = args;
+  let { handle } = args;
+
+  // Validate observation
+  if (!observation || observation.trim().length === 0) {
+    return {
+      display: 'Usage: `vibe remember "observation"` or `vibe remember @handle "observation"`'
+    };
+  }
+
+  // Clean handle
+  if (handle) {
+    handle = handle.replace(/^@/, '').toLowerCase();
+  } else {
+    // Try to find last active thread
+    const myHandle = config.getHandle();
+    const inbox = await store.getInbox(myHandle);
+
+    if (inbox && inbox.length > 0) {
+      // Use most recent thread
+      handle = inbox[0].handle;
+    } else {
+      return {
+        display: '**No thread context.** Use `vibe remember @handle "observation"` to specify who this memory is about.'
+      };
+    }
+  }
+
+  // Save the memory
+  const saved = memory.remember(handle, observation.trim());
+  const count = memory.count(handle);
+
+  // Format confirmation
+  let output = `## Memory Saved\n\n`;
+  output += `**About:** @${handle}\n`;
+  output += `**Observation:** "${saved.observation}"\n`;
+  output += `**Time:** ${new Date(saved.timestamp).toLocaleString()}\n\n`;
+  output += `---\n`;
+  output += `_Thread now has ${count} ${count === 1 ? 'memory' : 'memories'}. View with \`vibe recall @${handle}\`_\n`;
+  output += `_Inspect: \`${memory.getThreadFile(handle)}\`_`;
+
+  return { display: output };
+}
+
+module.exports = { definition, handler };