slashvibe-mcp 0.2.9 → 0.3.13

package/tools/reputation.js

@@ -0,0 +1,175 @@
+/**
+ * vibe_reputation - Check your reputation score and tier
+ *
+ * View your standing in the /vibe social hierarchy
+ *
+ * Examples:
+ * - "vibe reputation"
+ * - "check my tier"
+ * - "show my badges"
+ * - "vibe rep leaderboard"
+ */
+
+const fetch = require('node-fetch');
+
+module.exports = {
+  name: 'vibe_reputation',
+  description: 'Check your reputation score, tier, badges, and ranking. Shows economic, social, expert, and creator scores.',
+
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['score', 'leaderboard'],
+        description: 'Action: score (your stats) or leaderboard (top users)',
+        default: 'score'
+      },
+      dimension: {
+        type: 'string',
+        enum: ['overall', 'economic', 'social', 'expert', 'creator'],
+        description: 'Leaderboard dimension (only for leaderboard action)',
+        default: 'overall'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number of users to show in leaderboard (default 10)',
+        default: 10
+      }
+    }
+  },
+
+  async execute({ action = 'score', dimension = 'overall', limit = 10 }, context) {
+    try {
+      const handle = context.handle;
+
+      if (!handle) {
+        return {
+          success: false,
+          error: 'Not authenticated. Use vibe init first.'
+        };
+      }
+
+      const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+      if (action === 'score') {
+        const response = await fetch(
+          `${apiUrl}/api/reputation/score?handle=${handle}`,
+          {
+            headers: {
+              'Authorization': `Bearer ${context.token}`
+            }
+          }
+        );
+
+        const result = await response.json();
+
+        if (!response.ok) {
+          return {
+            success: false,
+            error: result.error || 'Failed to fetch reputation',
+            message: result.message
+          };
+        }
+
+        const tierIcons = {
+          genesis: '🌱',
+          bronze: '🥉',
+          silver: '🥈',
+          gold: '🥇',
+          platinum: '💎',
+          diamond: '👑'
+        };
+
+        const progressBar = '█'.repeat(Math.floor(result.progress_to_next * 20)) +
+                           '░'.repeat(20 - Math.floor(result.progress_to_next * 20));
+
+        const badgeList = result.badges?.slice(0, 5).map(b =>
+          `  ${b.icon || '🏆'} ${b.name} (${b.rarity})`
+        ) || [];
+
+        return {
+          success: true,
+          reputation: result,
+          formatted: `
+⭐ Reputation: ${handle}
+
+Tier: ${tierIcons[result.tier] || ''} ${result.tier.toUpperCase()}
+Overall Score: ${result.overall_score}
+Global Rank: #${result.rank} (top ${result.percentile.toFixed(1)}%)
+
+Dimension Scores:
+  💰 Economic: ${result.scores.economic}
+  👥 Social: ${result.scores.social}
+  🎓 Expert: ${result.scores.expert}
+  🎨 Creator: ${result.scores.creator}
+
+Progress to ${result.next_tier?.toUpperCase() || 'MAX'}:
+  [${progressBar}] ${(result.progress_to_next * 100).toFixed(1)}%
+  ${result.points_needed > 0 ? `${result.points_needed} points needed` : 'Max tier reached!'}
+
+Badges (${result.badges?.length || 0}):
+${badgeList.length > 0 ? badgeList.join('\n') : '  No badges yet'}
+
+Tier Unlocks:
+  ${JSON.stringify(result.tier_unlocks, null, 2).replace(/[{}"]/g, '').trim()}
+          `.trim()
+        };
+
+      } else if (action === 'leaderboard') {
+        const response = await fetch(
+          `${apiUrl}/api/reputation/leaderboard?dimension=${dimension}&limit=${Math.min(limit, 50)}`,
+          {
+            headers: {
+              'Authorization': `Bearer ${context.token}`
+            }
+          }
+        );
+
+        const result = await response.json();
+
+        if (!response.ok) {
+          return {
+            success: false,
+            error: 'Failed to fetch leaderboard'
+          };
+        }
+
+        const tierIcons = {
+          genesis: '🌱',
+          bronze: '🥉',
+          silver: '🥈',
+          gold: '🥇',
+          platinum: '💎',
+          diamond: '👑'
+        };
+
+        const leaderboardLines = result.leaderboard?.map(user => {
+          const tier = tierIcons[user.tier] || '';
+          const scoreField = dimension === 'overall' ? user.overall_score : user.score;
+          return `  ${user.rank}. ${user.handle.padEnd(15)} ${scoreField.toString().padStart(5)} ${tier} ${user.tier}`;
+        }) || [];
+
+        return {
+          success: true,
+          leaderboard: result.leaderboard,
+          formatted: `
+🏆 Reputation Leaderboard (${dimension})
+
+${leaderboardLines.join('\n')}
+
+Dimension: ${dimension}
+Total users: ${result.leaderboard?.length || 0}
+          `.trim()
+        };
+      }
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Failed to fetch reputation',
+        details: error.message
+      };
+    }
+  }
+};

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,
+};