slashvibe-mcp 0.2.8 → 0.3.13

package/tools/reply.js

@@ -0,0 +1,166 @@
+/**
+ * vibe reply — Quick reply to the most recent unread message
+ *
+ * Streamlined flow: one command instead of inbox → open → dm
+ */
+
+const config = require('../config');
+const store = require('../store');
+const patterns = require('../intelligence/patterns');
+const userProfiles = require('../store/profiles');
+const { trackMessage } = require('./summarize');
+const { requireInit, normalizeHandle, truncate, warning, fetchRelevantUsers } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
+
+const definition = {
+  name: 'vibe_reply',
+  description: 'Quick reply to your most recent unread message, or to a specific person. Streamlined: one command instead of inbox → open → dm.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      message: {
+        type: 'string',
+        description: 'Your reply message'
+      },
+      to: {
+        type: 'string',
+        description: 'Optional: reply to a specific person (e.g., @alex). If not provided, replies to most recent unread.'
+      }
+    },
+    required: ['message']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { message, to } = args;
+  const myHandle = config.getHandle();
+
+  if (!message || message.trim().length === 0) {
+    return { display: 'Need a message to reply with.' };
+  }
+
+  let targetHandle;
+  let threadContext = null;
+
+  // If specific recipient provided, use that
+  if (to) {
+    targetHandle = normalizeHandle(to);
+  } else {
+    // Find most recent unread thread
+    const threads = await store.getInbox(myHandle);
+
+    if (!threads || threads.length === 0) {
+      return {
+        display: '📭 No messages to reply to.\n\nUse `vibe dm @someone "message"` to start a conversation.',
+        actions: formatActions(actions.recommendedConnections([]))
+      };
+    }
+
+    // Find first thread with unread messages
+    const unreadThread = threads.find(t => t.unread > 0);
+
+    if (!unreadThread) {
+      // No unread, show most recent thread
+      const mostRecent = threads[0];
+      return {
+        display: `📭 All caught up! Most recent: @${mostRecent.handle}\n\nUse \`vibe reply "message" --to @${mostRecent.handle}\` to continue that conversation.`,
+        actions: formatActions(actions.afterInboxCompact([{ handle: mostRecent.handle, unread: 0 }]))
+      };
+    }
+
+    targetHandle = unreadThread.handle;
+    threadContext = {
+      unreadCount: unreadThread.unread,
+      preview: unreadThread.lastMessage ? truncate(unreadThread.lastMessage, 50) : null
+    };
+  }
+
+  // Can't reply to yourself
+  if (targetHandle === myHandle) {
+    return { display: 'You can\'t DM yourself.' };
+  }
+
+  // Route @echo messages to the echo agent
+  if (targetHandle === 'echo') {
+    const echo = require('./echo');
+    return echo.handler({ message, anonymous: false });
+  }
+
+  // Truncate message if too long
+  const MAX_LENGTH = 2000;
+  const trimmed = message.trim();
+  const wasTruncated = trimmed.length > MAX_LENGTH;
+  const finalMessage = wasTruncated ? trimmed.substring(0, MAX_LENGTH) : trimmed;
+
+  // Send typing indicator (shows "typing..." to recipient)
+  store.sendTypingIndicator(myHandle, targetHandle).catch(() => {});
+
+  // Send the message
+  const result = await store.sendMessage(myHandle, targetHandle, finalMessage, 'dm', null);
+
+  // Check for errors
+  if (result && result.error) {
+    return {
+      display: `❌ **Failed to send reply**\n\n${result.message}\n\n_Please try again._`
+    };
+  }
+
+  // Mark the thread as read since we're replying
+  try {
+    await store.markThreadRead(myHandle, targetHandle);
+  } catch (e) {
+    // Non-fatal - continue
+    console.warn('[reply] Failed to mark thread as read:', e.message);
+  }
+
+  // Log social pattern
+  patterns.logMessageSent(targetHandle);
+
+  // Record connection if first time
+  try {
+    const hasConnected = await userProfiles.hasBeenConnected(myHandle, targetHandle);
+    if (!hasConnected) {
+      await userProfiles.recordConnection(myHandle, targetHandle, 'first_message');
+    }
+  } catch (e) {
+    console.warn('[reply] Failed to update profile connection:', e);
+  }
+
+  // Track for session summary
+  trackMessage(myHandle, targetHandle, 'sent');
+
+  // Build response
+  let display = `✓ Replied to **@${targetHandle}**`;
+
+  if (wasTruncated) {
+    display += ` ${warning(`truncated to ${MAX_LENGTH} chars`)}`;
+  }
+
+  if (threadContext) {
+    display += `\n\n_${threadContext.unreadCount} message${threadContext.unreadCount > 1 ? 's' : ''} marked as read_`;
+  }
+
+  // Check for more unread
+  const remainingThreads = await store.getInbox(myHandle);
+  const stillUnread = remainingThreads.filter(t => t.unread > 0 && t.handle !== targetHandle);
+
+  if (stillUnread.length > 0) {
+    const nextHandle = stillUnread[0].handle;
+    const totalUnread = stillUnread.reduce((sum, t) => sum + t.unread, 0);
+    display += `\n\n📬 ${totalUnread} more unread from ${stillUnread.map(t => `@${t.handle}`).slice(0, 3).join(', ')}`;
+    display += `\n_Say \`vibe reply "message"\` to reply to @${nextHandle}_`;
+  }
+
+  // Build response with actions
+  const response = { display };
+
+  // Suggest follow-up actions
+  response.actions = formatActions(actions.afterDm(targetHandle));
+
+  return response;
+}
+
+module.exports = { definition, handler };

package/tools/report.js

@@ -87,7 +87,7 @@ If the problem persists, DM @vibe for help.`
     };
   }
 
-  let display = `## Report Submitted
+  const display = `## Report Submitted
 
 **Report ID:** ${result.report_id}
 **Reported:** @${reportedHandle}

package/tools/request.js

@@ -64,9 +64,16 @@ async function handler(args) {
   if (args.claim) {
     // Post a claim as a special entry
     try {
+      // Include auth token for API authorization
+      const authToken = config.getAuthToken();
+      const headers = { 'Content-Type': 'application/json' };
+      if (authToken) {
+        headers['Authorization'] = `Bearer ${authToken}`;
+      }
+
       const response = await fetch(`${apiUrl}/api/board`, {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
+        headers,
         body: JSON.stringify({
           author: myHandle,
           category: 'claim',
@@ -103,9 +110,16 @@ async function handler(args) {
     const fullContent = `${content}${bountyText}`;
 
     try {
+      // Include auth token for API authorization
+      const authToken = config.getAuthToken();
+      const headers = { 'Content-Type': 'application/json' };
+      if (authToken) {
+        headers['Authorization'] = `Bearer ${authToken}`;
+      }
+
       const response = await fetch(`${apiUrl}/api/board`, {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
+        headers,
         body: JSON.stringify({
           author: myHandle,
           category: 'request',
@@ -136,7 +150,7 @@ async function handler(args) {
   // Browse requests
   try {
     const limit = Math.min(args.limit || 10, 30);
-    let url = `${apiUrl}/api/board?limit=${limit * 2}&category=request`;
+    const url = `${apiUrl}/api/board?limit=${limit * 2}&category=request`;
 
     // Also get claims to show status
     const claimsUrl = `${apiUrl}/api/board?limit=50&category=claim`;

package/tools/schedule.js

@@ -0,0 +1,367 @@
+/**
+ * vibe schedule — Schedule and manage upcoming sessions
+ *
+ * Commands:
+ * - schedule "title" --time "tomorrow 3pm"  → Schedule a session
+ * - schedule list                           → Your scheduled sessions
+ * - schedule browse                         → All upcoming sessions
+ * - schedule rsvp <id>                      → RSVP to a session
+ * - schedule cancel <id>                    → Cancel your session
+ * - schedule myrsvps                        → Sessions you've RSVP'd to
+ */
+
+const config = require('../config');
+const { requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_schedule',
+  description: 'Schedule upcoming broadcast sessions. RSVP to sessions to get notified when they go live.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['create', 'list', 'browse', 'rsvp', 'cancel', 'myrsvps'],
+        description: 'Action: create, list, browse, rsvp, cancel, myrsvps'
+      },
+      title: {
+        type: 'string',
+        description: 'Session title (for create action)'
+      },
+      time: {
+        type: 'string',
+        description: 'When to schedule (e.g., "tomorrow 3pm", "2026-01-20T15:00:00Z")'
+      },
+      duration: {
+        type: 'number',
+        description: 'Estimated duration in minutes (default: 60)'
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Tags for the session (e.g., ["mcp", "ai"])'
+      },
+      scheduleId: {
+        type: 'string',
+        description: 'Schedule ID (for rsvp/cancel actions)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const myHandle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+  const action = args.action || 'browse';
+
+  try {
+    // CREATE — Schedule a new session
+    if (action === 'create') {
+      if (!args.title) {
+        return { display: '⚠️ Please provide a title: `vibe schedule create "Building X" --time "tomorrow 3pm"`' };
+      }
+
+      if (!args.time) {
+        return { display: '⚠️ Please provide a time: `vibe schedule create "Building X" --time "tomorrow 3pm"`' };
+      }
+
+      // Parse time string
+      const scheduledFor = parseTimeString(args.time);
+      if (!scheduledFor) {
+        return { display: '⚠️ Could not parse time. Try ISO format: `2026-01-20T15:00:00Z` or `tomorrow 3pm`' };
+      }
+
+      const response = await fetch(`${apiUrl}/api/sessions/schedule`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          handle: myHandle,
+          title: args.title,
+          scheduledFor: scheduledFor.toISOString(),
+          duration: args.duration || 60,
+          tags: args.tags || []
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      const schedule = data.schedule;
+      const dateStr = formatScheduleTime(schedule.scheduledFor);
+
+      let display = `## 📅 Session Scheduled!\n\n`;
+      display += `**${schedule.title}**\n`;
+      display += `📆 ${dateStr}\n`;
+      display += `⏱️ ~${schedule.duration} minutes\n\n`;
+      display += `**Share URL:**\n${schedule.shareUrl}\n\n`;
+      display += `Your followers will be notified.\n\n`;
+      display += `---\n`;
+      display += `_When it's time, use \`vibe broadcast start\` to go live._`;
+
+      return { display };
+    }
+
+    // LIST — My scheduled sessions
+    if (action === 'list') {
+      const response = await fetch(`${apiUrl}/api/sessions/schedule?handle=${myHandle}`);
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      if (data.schedules.length === 0) {
+        let display = `## My Scheduled Sessions\n\n`;
+        display += `_No upcoming sessions scheduled._\n\n`;
+        display += `**Schedule one:**\n`;
+        display += `\`vibe schedule create "Topic" --time "tomorrow 3pm"\``;
+        return { display };
+      }
+
+      let display = `## My Scheduled Sessions\n\n`;
+
+      for (const schedule of data.schedules) {
+        const dateStr = formatScheduleTime(schedule.scheduledFor);
+        display += `**${schedule.title}**\n`;
+        display += `📆 ${dateStr}`;
+        if (schedule.rsvpCount > 0) {
+          display += ` · 🎟️ ${schedule.rsvpCount} RSVPs`;
+        }
+        display += `\n`;
+        display += `ID: \`${schedule.id}\`\n\n`;
+      }
+
+      display += `---\n`;
+      display += `_Cancel: \`vibe schedule cancel <id>\`_`;
+
+      return { display };
+    }
+
+    // BROWSE — All upcoming sessions
+    if (action === 'browse') {
+      const response = await fetch(`${apiUrl}/api/sessions/schedule`);
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      if (data.schedules.length === 0) {
+        let display = `## Upcoming Sessions\n\n`;
+        display += `_No sessions scheduled yet._\n\n`;
+        display += `**Be the first:**\n`;
+        display += `\`vibe schedule create "Topic" --time "tomorrow 3pm"\``;
+        return { display };
+      }
+
+      let display = `## 📅 Upcoming Sessions\n\n`;
+
+      for (const schedule of data.schedules) {
+        const dateStr = formatScheduleTime(schedule.scheduledFor);
+        display += `**${schedule.title}**\n`;
+        display += `@${schedule.handle} · ${dateStr}`;
+        if (schedule.rsvpCount > 0) {
+          display += ` · 🎟️ ${schedule.rsvpCount}`;
+        }
+        display += `\n`;
+        if (schedule.tags && schedule.tags.length > 0) {
+          display += `🏷️ ${schedule.tags.join(', ')}\n`;
+        }
+        display += `\`vibe schedule rsvp ${schedule.id}\`\n\n`;
+      }
+
+      return { display };
+    }
+
+    // RSVP — RSVP to a session
+    if (action === 'rsvp') {
+      if (!args.scheduleId) {
+        return { display: '⚠️ Please provide a schedule ID: `vibe schedule rsvp sched_xxx`' };
+      }
+
+      const response = await fetch(`${apiUrl}/api/sessions/rsvp`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          scheduleId: args.scheduleId,
+          handle: myHandle
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      let display = `## 🎟️ RSVP Confirmed!\n\n`;
+      if (data.schedule) {
+        display += `**${data.schedule.title}**\n`;
+        display += `@${data.schedule.handle}\n`;
+        display += `📆 ${formatScheduleTime(data.schedule.scheduledFor)}\n\n`;
+      }
+      display += `You'll be notified when they go live.\n\n`;
+      display += `_${data.rsvpCount} people attending_`;
+
+      return { display };
+    }
+
+    // CANCEL — Cancel my session
+    if (action === 'cancel') {
+      if (!args.scheduleId) {
+        return { display: '⚠️ Please provide a schedule ID: `vibe schedule cancel sched_xxx`' };
+      }
+
+      const response = await fetch(`${apiUrl}/api/sessions/schedule`, {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          id: args.scheduleId,
+          handle: myHandle
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      return { display: `✅ Session cancelled. RSVPs have been notified.` };
+    }
+
+    // MYRSVPS — Sessions I've RSVP'd to
+    if (action === 'myrsvps') {
+      const response = await fetch(`${apiUrl}/api/sessions/rsvp?handle=${myHandle}`);
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      if (data.rsvps.length === 0) {
+        let display = `## My RSVPs\n\n`;
+        display += `_You haven't RSVP'd to any sessions._\n\n`;
+        display += `**Browse upcoming:**\n`;
+        display += `\`vibe schedule browse\``;
+        return { display };
+      }
+
+      let display = `## 🎟️ My RSVPs\n\n`;
+
+      for (const schedule of data.rsvps) {
+        const dateStr = formatScheduleTime(schedule.scheduledFor);
+        display += `**${schedule.title}**\n`;
+        display += `@${schedule.handle} · ${dateStr}\n\n`;
+      }
+
+      display += `_You'll be notified when these sessions go live._`;
+
+      return { display };
+    }
+
+    return { display: 'Unknown action. Use: create, list, browse, rsvp, cancel, myrsvps' };
+
+  } catch (error) {
+    return { display: `## Error\n\n${error.message}` };
+  }
+}
+
+/**
+ * Parse natural language time strings
+ */
+function parseTimeString(timeStr) {
+  // Try ISO format first
+  const isoDate = new Date(timeStr);
+  if (!isNaN(isoDate.getTime())) {
+    return isoDate;
+  }
+
+  const now = new Date();
+  const lower = timeStr.toLowerCase();
+
+  // "tomorrow 3pm", "tomorrow at 3pm"
+  if (lower.includes('tomorrow')) {
+    const tomorrow = new Date(now);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+
+    const timeMatch = lower.match(/(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+    if (timeMatch) {
+      let hours = parseInt(timeMatch[1]);
+      const mins = parseInt(timeMatch[2]) || 0;
+      const ampm = timeMatch[3]?.toLowerCase();
+
+      if (ampm === 'pm' && hours < 12) hours += 12;
+      if (ampm === 'am' && hours === 12) hours = 0;
+
+      tomorrow.setHours(hours, mins, 0, 0);
+      return tomorrow;
+    }
+
+    // Default to noon
+    tomorrow.setHours(12, 0, 0, 0);
+    return tomorrow;
+  }
+
+  // "in 2 hours"
+  const inHoursMatch = lower.match(/in\s+(\d+)\s+hours?/);
+  if (inHoursMatch) {
+    const hours = parseInt(inHoursMatch[1]);
+    return new Date(now.getTime() + hours * 60 * 60 * 1000);
+  }
+
+  // "next monday 3pm"
+  const dayNames = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+  for (let i = 0; i < dayNames.length; i++) {
+    if (lower.includes(dayNames[i])) {
+      const targetDay = i;
+      const currentDay = now.getDay();
+      let daysUntil = targetDay - currentDay;
+      if (daysUntil <= 0) daysUntil += 7;
+
+      const targetDate = new Date(now);
+      targetDate.setDate(targetDate.getDate() + daysUntil);
+
+      const timeMatch = lower.match(/(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+      if (timeMatch) {
+        let hours = parseInt(timeMatch[1]);
+        const mins = parseInt(timeMatch[2]) || 0;
+        const ampm = timeMatch[3]?.toLowerCase();
+
+        if (ampm === 'pm' && hours < 12) hours += 12;
+        if (ampm === 'am' && hours === 12) hours = 0;
+
+        targetDate.setHours(hours, mins, 0, 0);
+      } else {
+        targetDate.setHours(12, 0, 0, 0);
+      }
+
+      return targetDate;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Format schedule time for display
+ */
+function formatScheduleTime(isoString) {
+  const date = new Date(isoString);
+  return date.toLocaleDateString('en-US', {
+    weekday: 'short',
+    month: 'short',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    timeZoneName: 'short'
+  });
+}
+
+module.exports = { definition, handler };

package/tools/search-messages.js

@@ -0,0 +1,123 @@
+/**
+ * vibe_search_messages - Search your DM history
+ *
+ * Search through all your conversations or filter to a specific person.
+ * Returns matching messages with context highlighting.
+ */
+
+const config = require('../config');
+const store = require('../store');
+
+const searchMessagesSchema = {
+  name: 'vibe_search_messages',
+  description: 'Search through your DM history. Find messages by keyword across all conversations or with a specific person.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'Search term (at least 2 characters)',
+      },
+      with: {
+        type: 'string',
+        description: 'Optional: Filter to conversation with specific user (e.g., @alice)',
+      },
+      limit: {
+        type: 'number',
+        description: 'Max results to return (default: 20)',
+      },
+    },
+    required: ['query'],
+  },
+};
+
+async function searchMessagesHandler({ query, with: withUser, limit = 20 }) {
+  const handle = config.getHandle();
+  if (!handle) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: '❌ Not initialized. Run `vibe init` first.',
+        },
+      ],
+    };
+  }
+
+  if (!query || query.trim().length < 2) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: '❌ Search query must be at least 2 characters.',
+        },
+      ],
+    };
+  }
+
+  try {
+    const results = await store.searchMessages(query, {
+      with: withUser?.replace('@', ''),
+      limit: Math.min(limit, 50),
+    });
+
+    if (!results.messages || results.messages.length === 0) {
+      const scope = withUser ? ` in conversation with @${withUser.replace('@', '')}` : '';
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `🔍 No messages found for "${query}"${scope}.`,
+          },
+        ],
+      };
+    }
+
+    // Format results
+    let output = `🔍 **Search: "${query}"**\n`;
+    output += `Found ${results.total} message${results.total !== 1 ? 's' : ''}`;
+    if (withUser) {
+      output += ` with @${withUser.replace('@', '')}`;
+    }
+    output += '\n\n';
+
+    for (const msg of results.messages) {
+      const fromMe = msg.from === handle;
+      const direction = fromMe ? '→' : '←';
+      const other = fromMe ? msg.to : msg.from;
+      const date = new Date(msg.created_at).toLocaleDateString();
+
+      output += `**${direction} @${other}** (${date})\n`;
+      output += `> ${msg.match_preview}\n\n`;
+    }
+
+    if (results.has_more) {
+      output += `_Showing ${results.count} of ${results.total} results. Add \`limit: ${limit + 20}\` for more._\n`;
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: output,
+        },
+      ],
+    };
+
+  } catch (error) {
+    console.error('[search-messages] Error:', error);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ Search failed: ${error.message}`,
+        },
+      ],
+    };
+  }
+}
+
+module.exports = {
+  schema: searchMessagesSchema,
+  handler: searchMessagesHandler,
+};