slashvibe-mcp 0.2.9 → 0.3.13

package/tools/onboarding.js

@@ -0,0 +1,147 @@
+/**
+ * vibe onboarding — View your onboarding checklist progress
+ *
+ * Shows the 5 onboarding tasks and their completion status.
+ * Tasks are auto-detected as you use vibe.
+ */
+
+const config = require('../config');
+const store = require('../store');
+
+const definition = {
+  name: 'vibe_onboarding',
+  description: 'View your onboarding checklist progress. Shows tasks that help you get started with /vibe.',
+  inputSchema: {
+    type: 'object',
+    properties: {},
+    required: []
+  }
+};
+
+/**
+ * Format a single task for display
+ */
+function formatTask(task, index) {
+  const checkbox = task.completed ? '[x]' : '[ ]';
+  const status = task.completed ? '✓' : ' ';
+  const completedText = task.completed && task.completedAt
+    ? ` _(done ${formatTimeAgo(task.completedAt)})_`
+    : '';
+
+  return `${checkbox} **${task.title}**${completedText}`;
+}
+
+/**
+ * Format timestamp to relative time
+ */
+function formatTimeAgo(timestamp) {
+  const now = Date.now();
+  const then = new Date(timestamp).getTime();
+  const seconds = Math.floor((now - then) / 1000);
+
+  if (seconds < 60) return 'just now';
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+
+/**
+ * Generate progress bar
+ */
+function generateProgressBar(completed, total) {
+  const percentage = Math.round((completed / total) * 100);
+  const filled = Math.round((completed / total) * 10);
+  const empty = 10 - filled;
+  const bar = '█'.repeat(filled) + '░'.repeat(empty);
+  return `${bar} ${percentage}%`;
+}
+
+async function handler(args) {
+  const handle = config.getHandle();
+
+  if (!handle) {
+    return {
+      display: `## Not Initialized
+
+Run \`vibe init\` first to set your identity and start onboarding.`
+    };
+  }
+
+  // Fetch checklist status from API
+  try {
+    const response = await store.getChecklistStatus(handle);
+
+    if (!response.success) {
+      return {
+        display: `## Onboarding Checklist
+
+_Unable to load checklist. Try again later._
+
+Error: ${response.error || 'Unknown error'}`
+      };
+    }
+
+    const { tasks, progress, allComplete } = response;
+
+    // Build display
+    let display = `## Onboarding Checklist
+
+`;
+
+    // Progress bar
+    display += `**Progress:** ${generateProgressBar(progress.completed, progress.total)} (${progress.completed}/${progress.total})\n\n`;
+
+    // Celebration if complete
+    if (allComplete) {
+      display += `🎉 **Congratulations!** You've completed onboarding!\n\n`;
+    }
+
+    // Tasks
+    display += `### Tasks\n\n`;
+    tasks.forEach((task, i) => {
+      display += formatTask(task, i) + '\n';
+    });
+
+    // Next action hints
+    if (!allComplete) {
+      display += '\n### Quick Actions\n\n';
+
+      const nextTask = tasks.find(t => !t.completed);
+      if (nextTask) {
+        switch (nextTask.id) {
+          case 'read_welcome':
+            display += '→ Say **"check my messages"** to read @seth\'s welcome\n';
+            break;
+          case 'reply_seth':
+            display += '→ Say **"reply to seth"** or **"dm @seth hi!"**\n';
+            break;
+          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;
+        }
+      }
+    }
+
+    return { display };
+
+  } catch (e) {
+    return {
+      display: `## Onboarding Checklist
+
+_Error loading checklist: ${e.message}_
+
+Try running \`vibe test\` to check connectivity.`
+    };
+  }
+}
+
+module.exports = { definition, handler };

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

@@ -15,7 +15,7 @@ const werewolf = require('../games/werewolf');
 
 // Post game results to board
 async function postPartyGameResult(game, message) {
-  const API_URL = process.env.VIBE_API_URL || 'https://slashvibe.dev';
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
 
   try {
     await fetch(`${API_URL}/api/board`, {
@@ -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/presence-agent.js

@@ -6,6 +6,7 @@
  */
 
 const config = require('../config');
+const analytics = require('../analytics');
 
 const definition = {
   name: 'vibe_presence_agent',
@@ -81,6 +82,9 @@ ${running ? '**Commands:**\n- `mute vibe for 1 hour` - Pause alerts\n- `stop pre
     config.set('presenceAgentRunning', true);
     config.set('presenceAgentStartedAt', Date.now());
 
+    // Track lurk mode enabled for retention analytics
+    analytics.trackLurkMode(true);
+
     return {
       display: `## 🟢 Presence Monitor Started
 
@@ -141,6 +145,9 @@ You can keep working - I'll alert you when something important happens.`,
     config.set('presenceAgentRunning', false);
     config.set('presenceAgentStartedAt', null);
 
+    // Track lurk mode disabled for retention analytics
+    analytics.trackLurkMode(false);
+
     return {
       display: `## ⚪ Presence Monitor Stopped${durationText}