slashvibe-mcp 0.2.9 → 0.3.13

package/tools/work-summary.js

@@ -0,0 +1,96 @@
+/**
+ * vibe_work_summary — Standalone tool for explicit context gathering
+ *
+ * Use this when you need to:
+ * - Draft a message about what you're working on
+ * - Share your progress with someone
+ * - Get context for composing a "ship" post
+ *
+ * This tool returns structured data about:
+ * - Git state (branch, recent commits, changed files)
+ * - Project info (name, type)
+ * - Pre-formatted suggestions ready for messages/presence
+ */
+
+const { gatherWorkContext } = require('./_work-context');
+
+const definition = {
+  name: 'vibe_work_summary',
+  description: 'Get a summary of what you\'re working on (git state, project info). Use before composing messages about your work.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      detail_level: {
+        type: 'string',
+        enum: ['brief', 'detailed'],
+        description: 'brief = one-liner, detailed = include commits/files'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const { detail_level = 'brief' } = args;
+
+  // Gather all context
+  const context = gatherWorkContext();
+
+  // Build display based on detail level
+  let display = '## Work Context\n\n';
+
+  // Project info
+  display += `**Project:** ${context.project.name}`;
+  if (context.project.type !== 'unknown') {
+    display += ` (${context.project.type})`;
+  }
+  display += '\n';
+
+  // Git info
+  if (context.git) {
+    display += `**Branch:** ${context.git.branch}\n`;
+
+    if (detail_level === 'detailed') {
+      // Show recent commits
+      if (context.git.recentCommits.length > 0) {
+        display += '\n**Recent commits:**\n';
+        context.git.recentCommits.forEach(c => {
+          display += `- \`${c.hash}\` ${c.message}\n`;
+        });
+      }
+
+      // Show changed files
+      if (context.git.changedFiles.length > 0) {
+        display += '\n**Changed files:**\n';
+        context.git.changedFiles.forEach(f => {
+          display += `- ${f}\n`;
+        });
+      }
+
+      // Uncommitted changes indicator
+      if (context.git.hasUncommitted) {
+        display += '\n⚠️ _Uncommitted changes_\n';
+      }
+    }
+  } else {
+    display += '_Not in a git repository_\n';
+  }
+
+  // Suggestions
+  display += '\n---\n\n';
+  display += '**Ready to use:**\n';
+  display += `- Brief: "${context.suggestions.brief}"\n`;
+  if (detail_level === 'detailed' && context.suggestions.detailed !== context.suggestions.brief) {
+    display += `- Detailed: "${context.suggestions.detailed}"\n`;
+  }
+
+  display += '\n_Use these in messages, status updates, or ship posts._';
+
+  return {
+    display,
+    // Structured data for Claude to use programmatically
+    ...context,
+    usage_hint: 'Use suggestions.brief for messages, suggestions.detailed for updates.'
+  };
+}
+
+module.exports = { definition, handler };

package/tools/workshop.js

@@ -0,0 +1,327 @@
+/**
+ * vibe workshop — Access the /vibe game workshop and arcade
+ *
+ * Play solo games, join multiplayer sessions, browse the game collection
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { createGamePayload } = require('../protocol');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Import game implementations
+const arcade = require('../games/arcade');
+const drawing = require('../games/drawing');
+const hangman = require('../games/hangman');
+const wordchain = require('../games/wordchain');
+const twentyquestions = require('../games/twentyquestions');
+const snake = require('../games/snake');
+const memory = require('../games/memory');
+const rockpaperscissors = require('../games/rockpaperscissors');
+
+// Workshop shared game sessions (in-memory for now)
+const gameSessions = new Map();
+
+const definition = {
+  name: 'vibe_workshop',
+  description: 'Access the /vibe game workshop and arcade. Play games, join collaborative sessions, browse the collection',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      game: {
+        type: 'string',
+        description: 'Game to play or "arcade" to browse all games',
+        enum: ['arcade', 'drawing', 'hangman', 'wordchain', 'twentyquestions', 'snake', 'memory', 'rockpaperscissors']
+      },
+      action: {
+        type: 'string',
+        description: 'Action to take (join, move, draw, guess, etc.)'
+      },
+      x: {
+        type: 'number',
+        description: 'X coordinate for drawing games'
+      },
+      y: {
+        type: 'number',
+        description: 'Y coordinate for drawing games'
+      },
+      char: {
+        type: 'string',
+        description: 'Character to draw (use character names like "dot", "star", "heart")'
+      },
+      guess: {
+        type: 'string',
+        description: 'Letter or word to guess'
+      },
+      command: {
+        type: 'string',
+        description: 'Game-specific command or arcade navigation'
+      }
+    },
+    required: ['game']
+  }
+};
+
+/**
+ * Get or create a shared game session
+ */
+function getGameSession(gameType, sessionId = 'default') {
+  const key = `${gameType}:${sessionId}`;
+  
+  if (!gameSessions.has(key)) {
+    let initialState;
+    
+    switch (gameType) {
+      case 'drawing':
+        initialState = drawing.createInitialDrawingState();
+        break;
+      case 'hangman':
+        initialState = require('../games/hangman').createInitialHangmanState();
+        break;
+      case 'wordchain':
+        initialState = require('../games/wordchain').createInitialWordChainState();
+        break;
+      case 'twentyquestions':
+        initialState = require('../games/twentyquestions').createInitialTwentyQuestionsState();
+        break;
+      case 'snake':
+        initialState = require('../games/snake').createInitialSnakeState();
+        break;
+      case 'memory':
+        initialState = require('../games/memory').createInitialMemoryState();
+        break;
+      case 'rockpaperscissors':
+        initialState = require('../games/rockpaperscissors').createInitialRPSState();
+        break;
+      case 'arcade':
+        initialState = arcade.createInitialArcadeState();
+        break;
+      default:
+        throw new Error(`Unknown game type: ${gameType}`);
+    }
+    
+    gameSessions.set(key, initialState);
+  }
+  
+  return gameSessions.get(key);
+}
+
+/**
+ * Update a game session
+ */
+function updateGameSession(gameType, newState, sessionId = 'default') {
+  const key = `${gameType}:${sessionId}`;
+  gameSessions.set(key, newState);
+}
+
+/**
+ * Post activity to board when someone ships something cool
+ */
+async function postToBoard(content) {
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+  try {
+    await fetch(`${API_URL}/api/board`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        author: 'games-agent',
+        content,
+        category: 'general'
+      })
+    });
+  } catch (e) {
+    console.error('[workshop] Failed to post to board:', e.message);
+  }
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { game, action, x, y, char, guess, command } = args;
+  const myHandle = config.getHandle();
+
+  try {
+    // Handle arcade browsing
+    if (game === 'arcade') {
+      const gameState = getGameSession('arcade');
+      
+      if (command) {
+        const result = arcade.handleArcadeCommand(gameState, command);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameSession('arcade', result.gameState);
+        return { display: arcade.formatArcadeDisplay(result.gameState) };
+      }
+      
+      return { display: arcade.formatArcadeDisplay(gameState) };
+    }
+
+    // Handle collaborative drawing
+    if (game === 'drawing') {
+      const gameState = getGameSession('drawing');
+      
+      // Join the drawing session
+      if (!gameState.players.includes(myHandle)) {
+        const joinResult = drawing.addPlayer(gameState, myHandle);
+        if (joinResult.error) {
+          return { display: `❌ ${joinResult.error}` };
+        }
+        updateGameSession('drawing', joinResult.gameState);
+        
+        // Announce new artist
+        postToBoard(`🎨 @${myHandle} joined the collaborative drawing session!`);
+      }
+      
+      const currentGameState = getGameSession('drawing');
+      
+      // Handle drawing actions
+      if (action === 'draw' && x !== undefined && y !== undefined && char) {
+        // Convert character name to actual character
+        const drawChar = drawing.DRAWING_CHARS[char] || char;
+        const result = drawing.makeMove(currentGameState, x, y, drawChar, myHandle);
+        
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        
+        updateGameSession('drawing', result.gameState);
+        return { 
+          display: `✏️ Drew ${drawChar} at (${x},${y})\n\n${drawing.formatDrawingDisplay(result.gameState)}`
+        };
+      }
+      
+      if (action === 'line' && command) {
+        // Parse line command: "x0,y0 to x1,y1 with char"
+        const match = command.match(/(\d+),(\d+)\s+to\s+(\d+),(\d+)\s+with\s+(\w+)/);
+        if (match) {
+          const [, x0, y0, x1, y1, charName] = match;
+          const drawChar = drawing.DRAWING_CHARS[charName] || charName;
+          const result = drawing.drawLine(currentGameState, parseInt(x0), parseInt(y0), parseInt(x1), parseInt(y1), drawChar, myHandle);
+          
+          if (result.error) {
+            return { display: `❌ ${result.error}` };
+          }
+          
+          updateGameSession('drawing', result.gameState);
+          return { 
+            display: `✏️ Drew line from (${x0},${y0}) to (${x1},${y1})\n\n${drawing.formatDrawingDisplay(result.gameState)}`
+          };
+        }
+      }
+      
+      if (action === 'clear' && command) {
+        // Parse clear command: "x0,y0 to x1,y1"
+        const match = command.match(/(\d+),(\d+)\s+to\s+(\d+),(\d+)/);
+        if (match) {
+          const [, x0, y0, x1, y1] = match;
+          const result = drawing.clearRegion(currentGameState, parseInt(x0), parseInt(y0), parseInt(x1), parseInt(y1), myHandle);
+          
+          if (result.error) {
+            return { display: `❌ ${result.error}` };
+          }
+          
+          updateGameSession('drawing', result.gameState);
+          return { 
+            display: `🧹 Cleared region (${x0},${y0}) to (${x1},${y1})\n\n${drawing.formatDrawingDisplay(result.gameState)}`
+          };
+        }
+      }
+      
+      if (action === 'theme' && command) {
+        const result = drawing.setTheme(currentGameState, command, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        
+        updateGameSession('drawing', result.gameState);
+        const tips = drawing.getDrawingTips(command);
+        return { 
+          display: `🎯 Set theme: ${command}\n\n**Tips:** ${tips.join(', ')}\n\n${drawing.formatDrawingDisplay(result.gameState)}`
+        };
+      }
+      
+      if (action === 'stats') {
+        const stats = drawing.getCanvasStats(currentGameState);
+        return {
+          display: `📊 **Canvas Statistics**\n\n` +
+                   `• Total moves: ${stats.totalMoves}\n` +
+                   `• Canvas filled: ${stats.fillPercentage}%\n` +
+                   `• Characters used: ${stats.uniqueCharsUsed}\n` +
+                   `• Most popular: ${stats.mostUsedChar?.[0] || 'none'} (${stats.mostUsedChar?.[1] || 0} times)\n\n` +
+                   `${drawing.formatDrawingDisplay(currentGameState)}`
+        };
+      }
+      
+      // Default: show drawing canvas
+      return { display: drawing.formatDrawingDisplay(currentGameState) };
+    }
+
+    // Handle solo hangman
+    if (game === 'hangman') {
+      const gameState = getGameSession('hangman', myHandle); // Personal session
+      
+      if (action === 'guess' && guess) {
+        const hangmanModule = require('../games/hangman');
+        const result = hangmanModule.makeGuess(gameState, guess);
+        
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        
+        updateGameSession('hangman', result.gameState, myHandle);
+        
+        let response = hangmanModule.formatHangmanDisplay(result.gameState);
+        
+        if (result.gameState.won) {
+          response += '\n\n🎉 **You won!** Starting a new game...';
+          // Start new game
+          const newState = hangmanModule.createInitialHangmanState();
+          updateGameSession('hangman', newState, myHandle);
+        } else if (result.gameState.lost) {
+          response += '\n\n💀 **Game over!** Starting a new game...';
+          // Start new game
+          const newState = hangmanModule.createInitialHangmanState();
+          updateGameSession('hangman', newState, myHandle);
+        }
+        
+        return { display: response };
+      }
+      
+      if (action === 'new') {
+        const hangmanModule = require('../games/hangman');
+        const newState = hangmanModule.createInitialHangmanState();
+        updateGameSession('hangman', newState, myHandle);
+        return { display: hangmanModule.formatHangmanDisplay(newState) };
+      }
+      
+      // Default: show current game
+      const hangmanModule = require('../games/hangman');
+      return { display: hangmanModule.formatHangmanDisplay(gameState) };
+    }
+
+    // Handle other games similarly...
+    // For now, return a helpful message for unsupported games
+    const supportedGames = ['arcade', 'drawing', 'hangman'];
+    if (!supportedGames.includes(game)) {
+      return { 
+        display: `🎮 **${game.charAt(0).toUpperCase() + game.slice(1)}** game support coming soon!\n\n` +
+                 `Currently available:\n` +
+                 `• **arcade** - Browse all games\n` +
+                 `• **drawing** - Collaborative drawing canvas\n` +
+                 `• **hangman** - Solo word guessing\n\n` +
+                 `Use \`vibe workshop arcade\` to explore all games!`
+      };
+    }
+
+    return { display: 'Use --action to interact with the game!' };
+
+  } catch (error) {
+    console.error('[workshop] Error:', error);
+    return { display: `❌ Workshop error: ${error.message}` };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/x-mentions.js

@@ -9,7 +9,7 @@ const { requireInit, header, divider, formatTimeAgo } = require('./_shared');
 
 const definition = {
   name: 'vibe_x_mentions',
-  description: 'See your X/Twitter mentions. Search triggers: "twitter", "X", "mentions", "social media", "notifications". Pulls recent @mentions from X/Twitter into /vibe for triage and response.',
+  description: 'See your recent X/Twitter mentions. Brings X activity into /vibe.',
   inputSchema: {
     type: 'object',
     properties: {

package/version.json

@@ -1,5 +1,16 @@
 {
-  "version": "0.2.3",
-  "updated": "2026-01-09",
-  "changelog": "Postgres funnel tracking, KV rate limit fixes, stats accuracy"
+  "version": "0.3.13",
+  "updated": "2026-01-22",
+  "changelog": "Platform polish: smart inbox, streaks, leaderboards, gig recommendations, mobile dashboard",
+  "features": [
+    "Smart inbox checking - triggers on commits, tests, builds, natural breaks",
+    "Tech stack auto-detection for better connection matching",
+    "Enhanced streak system - 5 badge tiers, freeze preservation",
+    "Leaderboard 2.1 - category rankings, position tracking, movers",
+    "Featured sessions in browse",
+    "Gig recommendations based on proven skills",
+    "Mobile dashboard API for fast loading"
+  ],
+  "breaking": false,
+  "updateUrl": "https://www.slashvibe.dev/api/version"
 }

package/tools/artifacts-buy.js

@@ -1,111 +0,0 @@
-/**
- * vibe artifacts-buy — Purchase an artifact
- *
- * Buy artifacts from other developers. Part of the proof-of-work monetization layer.
- * PAST (artifacts for sale) ← PRESENT (watch me code) → FUTURE (gigs)
- */
-
-const config = require('../config');
-const { requireInit } = require('./_shared');
-
-const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
-
-const definition = {
-  name: 'vibe_artifacts_buy',
-  description: 'Purchase an artifact from another developer. Part of the proof-of-work monetization layer. Search triggers: "buy artifact", "purchase artifact", "get artifact".',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      artifact_id: {
-        type: 'string',
-        description: 'The artifact ID to purchase (e.g., "artifact_xxx")'
-      },
-      amount_cents: {
-        type: 'number',
-        description: 'Optional: Amount to pay in cents. Required for pay_what_you_want, defaults to artifact price otherwise.'
-      }
-    },
-    required: ['artifact_id']
-  }
-};
-
-async function handler(args) {
-  const initCheck = requireInit();
-  if (initCheck) return initCheck;
-
-  const { artifact_id, amount_cents } = args;
-  const buyer = config.getHandle();
-
-  if (!artifact_id) {
-    return {
-      display: '❌ Missing artifact_id. Provide the ID of the artifact to buy.'
-    };
-  }
-
-  try {
-    // First, get artifact details to show price
-    const artifactResponse = await fetch(`${API_URL}/api/artifacts?id=${encodeURIComponent(artifact_id)}`);
-    const artifactData = await artifactResponse.json();
-
-    if (!artifactData.success || !artifactData.artifact) {
-      return {
-        display: `❌ Artifact not found: ${artifact_id}`
-      };
-    }
-
-    const artifact = artifactData.artifact;
-
-    if (!artifact.is_for_sale) {
-      return {
-        display: `❌ This artifact is not for sale.`
-      };
-    }
-
-    if (artifact.created_by === buyer) {
-      return {
-        display: `❌ You can't buy your own artifact!`
-      };
-    }
-
-    // Calculate final amount
-    const finalAmount = amount_cents || artifact.price_cents;
-    const priceDisplay = `$${(finalAmount / 100).toFixed(2)}`;
-
-    // Make purchase
-    const response = await fetch(`${API_URL}/api/artifacts/purchase`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        artifact_id,
-        buyer,
-        amount_cents: finalAmount
-      })
-    });
-
-    const data = await response.json();
-
-    if (!data.success) {
-      return {
-        display: `❌ Purchase failed: ${data.error || 'Unknown error'}`
-      };
-    }
-
-    let display = `## 🎉 Artifact Purchased!\n\n`;
-    display += `**${artifact.title}**\n`;
-    display += `by @${artifact.created_by}\n\n`;
-    display += `**Amount paid:** ${priceDisplay}\n`;
-    display += `**View at:** https://slashvibe.dev/a/${artifact.slug}\n\n`;
-    display += `---\n`;
-    display += `You now have access to this artifact.\n`;
-    display += `The seller @${artifact.created_by} has been credited.`;
-
-    return { display };
-
-  } catch (e) {
-    return {
-      display: `❌ Error purchasing artifact: ${e.message}`
-    };
-  }
-}
-
-module.exports = { definition, handler };