slashvibe-mcp 0.2.8 → 0.3.13

package/tools/invite.js

@@ -203,14 +203,25 @@ _Copy the link above and send it._`
   const genNote = justGenerated ? ' (just generated)' : '';
   const randomMsg = INVITE_MESSAGES[Math.floor(Math.random() * INVITE_MESSAGES.length)];
 
+  // Build social share URLs
+  const tweetText = encodeURIComponent(`${randomMsg}\n\nhttps://${shareUrl}`);
+  const twitterUrl = `https://twitter.com/intent/tweet?text=${tweetText}`;
+
   return {
     display: `## Quick Invite${genNote}
 
-> ${randomMsg}
->
-> **${shareUrl}**
+**Copy this:**
+\`\`\`
+${randomMsg}
+
+https://${shareUrl}
+\`\`\`
+
+**Or share directly:**
+- [Tweet it](${twitterUrl})
+- Slack/Discord: Just paste the link above
 
-_Copy and send. ${shareCode ? `Bonus code earned when they join.` : ''}_`
+${shareCode ? `_When they join, you both get bonus codes._` : ''}`
   };
 }
 

package/tools/migrate.js

@@ -2,7 +2,7 @@
  * vibe migrate — Migrate existing handle to GitHub auth
  *
  * For users who have existing handles with local keypairs,
- * this command helps them migrate to the new Privy/GitHub auth.
+ * this command helps them migrate to GitHub OAuth auth.
  *
  * Flow:
  * 1. Check if user has existing handle and keys
@@ -36,8 +36,8 @@ If you're new, use \`vibe init @yourhandle "what you're building"\` instead.`
     };
   }
 
-  // Check if already using Privy auth
-  if (config.hasPrivyAuth()) {
+  // Check if already using GitHub auth
+  if (config.hasOAuth()) {
     return {
       display: `✅ **Already using GitHub auth**
 

package/tools/multiplayer-game.js

@@ -105,7 +105,7 @@ async function handler(args) {
   const roomId = roomName || 'default';
 
   // Get current game state
-  let gameState = getGameRoom(game, roomId);
+  const gameState = getGameRoom(game, roomId);
   
   try {
     if (game === 'drawing') {

package/tools/onboarding.js

@@ -110,23 +110,23 @@ Error: ${response.error || 'Unknown error'}`
       if (nextTask) {
         switch (nextTask.id) {
           case 'read_welcome':
-            display += '→ Say **"check my messages"** to read @vibe\'s welcome\n';
+            display += '→ Say **"check my messages"** to read @seth\'s welcome\n';
             break;
           case 'reply_seth':
-            display += '→ Say **"reply to vibe"** or **"dm @vibe hi!"**\n';
+            display += '→ Say **"reply to seth"** or **"dm @seth hi!"**\n';
             break;
-          case 'message_builder':
-            display += '→ Say **"who\'s around?"** then message someone\n';
+          case 'find_github_friends':
+            display += '→ Say **"find my github friends"** to see who you know! 🔥\n';
             break;
           case 'first_ship':
             display += '→ Say **"ship something"** or **"I shipped X"**\n';
             break;
+          case 'share_ship':
+            display += '→ After shipping, click the Twitter link to share! 🐦\n';
+            break;
           case 'invite_friend':
             display += '→ Say **"invite a friend"** or **"share my invite link"**\n';
             break;
-          case 'leave_feedback':
-            display += '→ Say **"echo feedback about X"** or **"give feedback"**\n';
-            break;
         }
       }
     }

package/tools/open.js

@@ -8,6 +8,15 @@ const memory = require('../memory');
 const patterns = require('../intelligence/patterns');
 const { formatPayload } = require('../protocol');
 const { requireInit, normalizeHandle } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
+
+// Truncate message for preview (first 100 chars, clean break at word)
+function summarizeMessage(text, maxLen = 100) {
+  if (!text || text.length <= maxLen) return text;
+  const truncated = text.slice(0, maxLen);
+  const lastSpace = truncated.lastIndexOf(' ');
+  return (lastSpace > maxLen * 0.7 ? truncated.slice(0, lastSpace) : truncated) + '...';
+}
 
 const definition = {
   name: 'vibe_open',
@@ -46,38 +55,152 @@ async function handler(args) {
     patterns.logMessageReceived(them);
   }
 
-  // Check if they're typing
+  // Check if they're typing (cross-platform: synced via KV)
   let typingNotice = '';
   try {
     const typingUsers = await store.getTypingUsers(myHandle);
-    if (typingUsers.includes(them)) {
+    const isTyping = typingUsers.some(t => t.handle?.toLowerCase() === them.toLowerCase());
+    if (isTyping) {
       typingNotice = `\n_@${them} is typing..._\n`;
     }
   } catch (e) {}
 
+  // Get their presence status (for "last seen" display)
+  let presenceStatus = '';
+  try {
+    const activeUsers = await store.getActiveUsers();
+    const theirPresence = activeUsers.find(u => u.handle?.toLowerCase() === them.toLowerCase());
+
+    if (theirPresence) {
+      if (theirPresence.status === 'active') {
+        presenceStatus = '🟢 online now';
+      } else if (theirPresence.status === 'away') {
+        const ago = store.formatTimeAgo(theirPresence.lastSeen);
+        presenceStatus = `☕ away · last seen ${ago}`;
+      } else {
+        const ago = store.formatTimeAgo(theirPresence.lastSeen);
+        presenceStatus = `last seen ${ago}`;
+      }
+    }
+  } catch (e) {}
+
   if (thread.length === 0) {
-    return {
-      display: `## @${them}
+    const statusLine = presenceStatus ? `\n_${presenceStatus}_` : '';
+
+    // Fetch conversation starters to help break the ice
+    let starters = [];
+    let starterContext = {};
+    try {
+      const apiUrl = config.getApiUrl();
+      const promptsResponse = await fetch(`${apiUrl}/api/prompts?from=${myHandle}&to=${them}`, {
+        headers: { 'User-Agent': 'vibe-mcp-client' }
+      });
+      if (promptsResponse.ok) {
+        const data = await promptsResponse.json();
+        if (data.success && data.prompts) {
+          starters = data.prompts.slice(0, 3);
+          starterContext = data.context || {};
+        }
+      }
+    } catch (e) {}
+
+    // Build display with conversation starters
+    let emptyDisplay = `## @${them}${statusLine}
 
 _No messages yet._${typingNotice}
+`;
+
+    if (starters.length > 0) {
+      emptyDisplay += `\n**💬 Conversation starters:**\n`;
+      starters.forEach((starter, i) => {
+        emptyDisplay += `${i + 1}. "${starter}"\n`;
+      });
+      emptyDisplay += `\n_Copy one or say your own!_`;
+    } else {
+      emptyDisplay += `\nSay "message ${them} hello" to start`;
+    }
+
+    // Build response with actions for quick-send
+    const response = { display: emptyDisplay };
+
+    if (starters.length > 0) {
+      response.actions = formatActions(starters.map((starter, i) => ({
+        label: `Send #${i + 1}`,
+        action: `vibe dm @${them} ${starter}`,
+        description: starter.slice(0, 40) + (starter.length > 40 ? '...' : '')
+      })));
+      response.conversationStarters = starters;
+      response.context = starterContext;
+    }
 
-Say "message ${them} hello" to start`
-    };
+    return response;
   }
 
-  // Check if they're an agent (from first message if available)
-  const theirMessage = thread.find(m => m.from === them);
-  const agentIndicator = theirMessage?.isAgent ? ' 🤖' : '';
+  // Get latest message from them for the summary preview
+  const latestFromThem = theirMessages.length > 0
+    ? theirMessages.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))[0]
+    : null;
+
+  // Build the preview summary line (what appears in collapsed view)
+  let display = '';
+
+  // Header with presence status
+  const statusSuffix = presenceStatus ? ` · _${presenceStatus}_` : '';
 
-  let display = `## Thread with @${them}${agentIndicator}\n\n`;
+  if (latestFromThem) {
+    const agentBadge = latestFromThem.isAgent ? ' 🤖' : '';
+    const time = store.formatTimeAgo(latestFromThem.timestamp);
+    const preview = latestFromThem.body
+      ? summarizeMessage(latestFromThem.body)
+      : (latestFromThem.payload ? '[attachment]' : '');
 
-  thread.forEach(m => {
+    display = `💬 @${them}${agentBadge}${statusSuffix}\n> (${time}): "${preview}"\n\n`;
+  } else {
+    // No messages from them yet - you sent first
+    display = `💬 @${them}${statusSuffix}\n> _Waiting for reply..._\n\n`;
+  }
+
+  // Thread section - sorted newest first so their latest message appears at top
+  display += `---\n📜 Thread\n\n`;
+
+  const sortedThread = [...thread].sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+
+  // Build a map for reply lookups
+  const messageMap = {};
+  thread.forEach(m => { messageMap[m.id] = m; });
+
+  sortedThread.forEach(m => {
     const isMe = m.from === myHandle;
     const agentBadge = m.isAgent && !isMe ? '🤖 ' : '';
     const sender = isMe ? 'you' : `@${m.from}`;
     const time = store.formatTimeAgo(m.timestamp);
 
-    display += `${agentBadge}**${sender}** — _${time}_\n`;
+    // Status indicator for sent messages: ✓ sent, ✓✓ delivered, ✓✓ read
+    let statusIndicator = '';
+    if (isMe) {
+      if (m.status === 'read' || m.readByThem) {
+        statusIndicator = ' ✓✓ read';
+      } else if (m.status === 'delivered' || m.delivered) {
+        statusIndicator = ' ✓✓';
+      } else {
+        statusIndicator = ' ✓';
+      }
+    }
+
+    display += `${agentBadge}**${sender}** — _${time}${statusIndicator}_\n`;
+
+    // Show reply context if this is a threaded reply
+    if (m.reply_to_id || m.replyToId) {
+      const replyToId = m.reply_to_id || m.replyToId;
+      const originalMsg = messageMap[replyToId];
+      if (originalMsg) {
+        const originalSender = originalMsg.from === myHandle ? 'you' : `@${originalMsg.from}`;
+        const preview = (originalMsg.body || '').substring(0, 50);
+        display += `> ↩ replying to ${originalSender}: "${preview}${preview.length >= 50 ? '...' : ''}"\n`;
+      } else {
+        display += `> ↩ _replying to earlier message_\n`;
+      }
+    }
 
     // Show text if present
     if (m.body) {
@@ -114,6 +237,14 @@ Say "message ${them} hello" to start`
     response.reason = 'long_thread';
   }
 
+  // Add smart reply actions based on their last message
+  if (latestFromThem && latestFromThem.body) {
+    response.actions = formatActions(actions.afterOpenThread(them, latestFromThem.body));
+  } else {
+    // No message from them yet - offer generic options
+    response.actions = formatActions(actions.afterOpenThread(them, ''));
+  }
+
   return response;
 }
 

package/tools/party-game.js

@@ -103,7 +103,7 @@ async function handler(args) {
   const gameKey = getGameKey(game, room || myHandle);
 
   // Get or create game state
-  let gameState = activeGames[gameKey];
+  const gameState = activeGames[gameKey];
 
   if (game === 'twotruths') {
     return handleTwoTruths(args, myHandle, gameKey, gameState);

package/tools/plan.js

@@ -0,0 +1,225 @@
+/**
+ * vibe_plan — Create a plan and request approval
+ *
+ * Plans are structured proposals that can be sent for async approval.
+ * They're artifacts with an approval workflow built in.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+const definition = {
+  name: 'vibe_plan',
+  description: 'Create a plan and request approval from collaborators. Plans are structured proposals with summary, problem, changes, and impact.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      title: {
+        type: 'string',
+        description: 'Plan title (e.g., "Refactor auth system", "CLAUDE.md cleanup")'
+      },
+      summary: {
+        type: 'string',
+        description: 'One-line summary of what this plan does'
+      },
+      problem: {
+        type: 'string',
+        description: 'What problem does this solve? (optional)'
+      },
+      changes: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'List of proposed changes'
+      },
+      impact: {
+        type: 'string',
+        description: 'What will be affected by this change? (optional)'
+      },
+      request_approval_from: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Handles to request approval from (e.g., ["@brightseth", "@alice"])'
+      },
+      requires: {
+        type: 'string',
+        enum: ['any', 'all'],
+        description: 'Require approval from any one person (default) or all of them'
+      }
+    },
+    required: ['title', 'summary', 'changes', 'request_approval_from']
+  }
+};
+
+// Generate artifact ID and slug
+function generateArtifactId() {
+  return `plan_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+}
+
+function generateSlug(title) {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .substring(0, 60);
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const {
+    title,
+    summary,
+    problem,
+    changes,
+    impact,
+    request_approval_from,
+    requires = 'any'
+  } = args;
+
+  const creator = config.getHandle();
+
+  // Validate approvers
+  if (!request_approval_from || request_approval_from.length === 0) {
+    return {
+      display: '❌ Must specify at least one approver in request_approval_from'
+    };
+  }
+
+  // Normalize approver handles
+  const approvers = request_approval_from.map(h => normalizeHandle(h));
+
+  // Build content blocks for the plan
+  const blocks = [
+    { type: 'summary', data: { text: summary } }
+  ];
+
+  if (problem) {
+    blocks.push({ type: 'problem', data: { text: problem } });
+  }
+
+  blocks.push({
+    type: 'proposed_changes',
+    data: { items: changes }
+  });
+
+  if (impact) {
+    blocks.push({ type: 'impact', data: { text: impact } });
+  }
+
+  // Build the plan artifact
+  const planId = generateArtifactId();
+  const slug = generateSlug(title);
+
+  // Build audience list (creator + all approvers)
+  const audience = new Set([creator, ...approvers]);
+
+  const plan = {
+    id: planId,
+    slug,
+    title,
+    template: 'plan',
+    content: { blocks },
+
+    // Social metadata
+    created_by: creator,
+    created_for: approvers[0],  // Primary approver
+    thread_id: null,
+
+    // Privacy - plans are unlisted by default
+    visibility: 'unlisted',
+    audience: Array.from(audience),
+
+    // Provenance
+    provenance: {
+      source_type: 'manual',
+      personalized_for: null,
+      notes: null
+    },
+
+    // Lifecycle
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    expires_at: null,
+
+    // Evolution
+    revision: 1,
+    forked_from: null,
+
+    // Approval workflow
+    approval: {
+      status: 'pending',
+      requested_from: approvers,
+      requires,
+      responses: [],
+      resolved_at: null
+    }
+  };
+
+  // Store the plan
+  const storeResult = await store.createArtifact(plan);
+
+  if (!storeResult.success) {
+    return {
+      display: `❌ Failed to create plan: ${storeResult.error}`
+    };
+  }
+
+  const planUrl = `https://slashvibe.dev/a/${slug}`;
+
+  // Send DM to each approver
+  const dmResults = [];
+  for (const approver of approvers) {
+    try {
+      const dmResult = await store.sendMessage(creator, approver,
+        `📋 **Plan: ${title}**\n\n` +
+        `**Summary:** ${summary}\n\n` +
+        (problem ? `**Problem:** ${problem}\n\n` : '') +
+        `**Changes:**\n${changes.map(c => `• ${c}`).join('\n')}\n\n` +
+        (impact ? `**Impact:** ${impact}\n\n` : '') +
+        `---\n` +
+        `👍 Approve · 🔄 Request changes · ❌ Reject\n` +
+        `Use: \`vibe approve ${slug}\` or \`vibe approve ${slug} --reject\``,
+        {
+          type: 'plan_card',
+          plan_id: planId,
+          plan_slug: slug,
+          plan_url: planUrl
+        }
+      );
+      dmResults.push({ approver, success: dmResult.success });
+    } catch (error) {
+      console.error(`[PLAN] Failed to DM ${approver}:`, error);
+      dmResults.push({ approver, success: false, error: error.message });
+    }
+  }
+
+  // Build response
+  const successfulDMs = dmResults.filter(r => r.success).length;
+  const approverList = approvers.map(a => `@${a}`).join(', ');
+
+  let display = `📋 **Plan created: ${title}**\n\n`;
+  display += `**Status:** ⏳ Pending approval\n`;
+  display += `**Requested from:** ${approverList}\n`;
+  display += `**Requires:** ${requires === 'all' ? 'All approvers' : 'Any approver'}\n\n`;
+
+  if (successfulDMs === approvers.length) {
+    display += `✓ Sent to ${successfulDMs} approver${successfulDMs > 1 ? 's' : ''}\n`;
+  } else {
+    display += `⚠️ Sent to ${successfulDMs}/${approvers.length} approvers\n`;
+  }
+
+  display += `\n**Plan ID:** \`${slug}\``;
+
+  return {
+    display,
+    plan_id: planId,
+    plan_slug: slug,
+    plan_url: planUrl,
+    approval_status: 'pending',
+    approvers
+  };
+}
+
+module.exports = { definition, handler };

package/tools/proof-of-work.js

@@ -0,0 +1,144 @@
+/**
+ * vibe_proof_of_work - Get unified proof-of-work summary for a user
+ *
+ * Shows the complete "proof of work" picture:
+ * - PAST: Artifacts created/sold, sessions shared
+ * - PRESENT: Live presence, current work
+ * - FUTURE: Gigs completed/posted, hire availability
+ * - UNIFIED: Vibe score, tier, proven skills
+ */
+
+const config = require('../config');
+const { requireInit, normalizeHandle, displayHandle, header, divider, emptyState, formatTimeAgo } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
+
+const BASE_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+const definition = {
+  name: 'vibe_proof_of_work',
+  description: 'Get proof-of-work summary for a user. Shows artifacts, sessions, gigs, vibe score, and proven skills.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'User handle to look up (default: yourself)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const targetHandle = normalizeHandle(args.handle) || config.getHandle();
+
+  try {
+    const response = await fetch(`${BASE_URL}/api/proof-of-work?handle=${encodeURIComponent(targetHandle)}`);
+    const data = await response.json();
+
+    if (!data.success) {
+      return { display: `❌ ${data.error || 'Failed to fetch proof-of-work'}` };
+    }
+
+    const pow = data.proof_of_work;
+    const isSelf = targetHandle === config.getHandle();
+
+    // Build display
+    let display = header(`Proof of Work: ${displayHandle(targetHandle)}`, 2) + '\n\n';
+
+    // Vibe Score & Tier
+    display += `**Vibe Score:** ${pow.unified?.vibe_score || 0}\n`;
+    display += `**Tier:** ${formatTier(pow.unified?.tier)}\n\n`;
+
+    // ━━━ PAST ━━━
+    display += header('📜 PAST (Artifacts & Sessions)', 3) + '\n';
+    const past = pow.past || {};
+    display += `• **Artifacts Created:** ${past.artifacts_created || 0}\n`;
+    display += `• **Artifacts Sold:** ${past.artifacts_sold || 0}\n`;
+    display += `• **Revenue Earned:** $${((past.revenue_cents || 0) / 100).toFixed(2)}\n`;
+    display += `• **Sessions Shared:** ${past.sessions_shared || 0}\n\n`;
+
+    // ━━━ PRESENT ━━━
+    display += header('🟢 PRESENT (Live)', 3) + '\n';
+    const present = pow.present || {};
+    if (present.is_online) {
+      display += `• **Status:** Online\n`;
+      if (present.working_on) {
+        display += `• **Working on:** ${present.working_on}\n`;
+      }
+      if (present.project) {
+        display += `• **Project:** ${present.project}\n`;
+      }
+    } else {
+      display += `• **Status:** Offline\n`;
+      if (present.last_seen) {
+        display += `• **Last seen:** ${formatTimeAgo(present.last_seen)}\n`;
+      }
+    }
+    display += '\n';
+
+    // ━━━ FUTURE ━━━
+    display += header('🚀 FUTURE (Gigs & Availability)', 3) + '\n';
+    const future = pow.future || {};
+    display += `• **Gigs Completed:** ${future.gigs_completed || 0}\n`;
+    display += `• **Gigs Posted:** ${future.gigs_posted || 0}\n`;
+    display += `• **Avg Rating:** ${future.avg_rating ? `${future.avg_rating.toFixed(1)}⭐` : 'No ratings yet'}\n`;
+    display += `• **Available for Hire:** ${future.available_for_hire ? 'Yes' : 'No'}\n\n`;
+
+    // ━━━ PROVEN SKILLS ━━━
+    const skills = pow.unified?.proven_skills || [];
+    if (skills.length > 0) {
+      display += header('🛠️ Proven Skills', 3) + '\n';
+      skills.slice(0, 10).forEach(skill => {
+        display += `• ${skill.name} (${skill.count} gig${skill.count !== 1 ? 's' : ''})\n`;
+      });
+      display += '\n';
+    }
+
+    // ━━━ SCORE BREAKDOWN ━━━
+    const breakdown = pow.unified?.score_breakdown;
+    if (breakdown) {
+      display += header('📊 Score Breakdown', 3) + '\n';
+      display += `• Gigs: ${breakdown.gigs || 0}\n`;
+      display += `• Artifacts: ${breakdown.artifacts || 0}\n`;
+      display += `• Sessions: ${breakdown.sessions || 0}\n`;
+      display += `• Invites: ${breakdown.invites || 0}\n`;
+      display += `• Ships: ${breakdown.ships || 0}\n`;
+    }
+
+    // CTA for self
+    if (isSelf) {
+      display += divider();
+      display += '💡 **Boost your score:** Complete gigs (+50), sell artifacts (+30), share sessions (+10)\n';
+    }
+
+    // Build result with tip actions
+    const result = { display };
+    result.actions = formatActions(actions.afterProofOfWork(targetHandle, isSelf));
+
+    return result;
+
+  } catch (e) {
+    console.error('[proof-of-work] Error:', e);
+    return { display: `❌ Failed to fetch proof-of-work: ${e.message}` };
+  }
+}
+
+/**
+ * Format tier with emoji
+ */
+function formatTier(tier) {
+  const tiers = {
+    newcomer: '🌱 Newcomer',
+    rising: '📈 Rising',
+    proven: '✅ Proven',
+    established: '🏆 Established',
+    expert: '⭐ Expert',
+    legendary: '👑 Legendary'
+  };
+  return tiers[tier] || tier || 'Unknown';
+}
+
+module.exports = { definition, handler };