slashvibe-mcp 0.3.20 → 0.3.21

package/tools/status.js

@@ -1,11 +1,14 @@
 /**
  * vibe status — Set your mood/status
+ *
+ * Now includes away/back functionality (previously vibe_away/vibe_back)
  */
 
 const config = require('../config');
 const store = require('../store');
 const discord = require('../discord');
 const { trackMood } = require('./summarize');
+const { markAway, markBack, getProactiveSummary } = require('../intelligence/proactive');
 
 const MOODS = {
   'shipping': '🔥',
@@ -16,6 +19,8 @@ const MOODS = {
   'deep': '🎧',
   'celebrating': '🎉',
   'struggling': '😤',
+  'away': '☕',    // Merged from vibe_away
+  'back': null,   // Merged from vibe_back (clears status)
   'clear': null
 };
 
@@ -24,13 +29,17 @@ const SPECIAL_MODES = ['guided', 'freeform'];
 
 const definition = {
   name: 'vibe_status',
-  description: 'Set your mood/status. Options: shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, clear',
+  description: 'Set your mood/status. Options: shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, away, back, clear',
   inputSchema: {
     type: 'object',
     properties: {
       mood: {
         type: 'string',
-        description: 'Your mood (shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, clear)'
+        description: 'Your mood (shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, away, back, clear)'
+      },
+      message: {
+        type: 'string',
+        description: 'Optional away message (only used with away mood, e.g., "grabbing coffee")'
       }
     },
     required: ['mood']
@@ -44,8 +53,9 @@ async function handler(args) {
     };
   }
 
-  const { mood } = args;
+  const { mood, message } = args;
   const moodKey = mood.toLowerCase().replace(/[^a-z]/g, '');
+  const handle = config.getHandle();
 
   // Handle special modes (guided/freeform)
   if (moodKey === 'guided') {
@@ -72,18 +82,55 @@ _Say "set status guided" to re-enable interactive menus._`
     };
   }
 
+  // Handle 'away' mood (merged from vibe_away)
+  if (moodKey === 'away') {
+    const awayMessage = message?.trim();
+
+    // Validate message length
+    if (awayMessage && awayMessage.length > 100) {
+      return { display: '⚠️ Away message too long (100 char max)' };
+    }
+
+    // Set away status with optional message
+    await store.setAwayStatus(handle, 'away', awayMessage || null);
+    markAway();
+
+    if (awayMessage) {
+      return { display: `☕ away — "${awayMessage}"` };
+    }
+    return { display: '☕ away' };
+  }
+
+  // Handle 'back' mood (merged from vibe_back)
+  if (moodKey === 'back') {
+    // Clear away status
+    await store.clearAwayStatus(handle);
+
+    let display = '👋 back';
+
+    // Check if anything happened while away
+    const unreadCount = await store.getUnreadCount(handle).catch(() => 0);
+    if (unreadCount > 0) {
+      display += ` — ${unreadCount} unread`;
+    }
+
+    // Mark as back for proactive tracking
+    markBack();
+
+    return { display };
+  }
+
   if (!MOODS.hasOwnProperty(moodKey)) {
     const options = Object.entries(MOODS)
-      .filter(([k, v]) => v)
+      .filter(([k, v]) => v && k !== 'back')  // Exclude 'back' from list (it's a clear action)
       .map(([k, v]) => `${v} ${k}`)
       .join(', ');
     return {
-      display: `Unknown mood. Options: ${options}, or "clear" to remove`
+      display: `Unknown mood. Options: ${options}, or "clear"/"back" to remove`
     };
   }
 
   const emoji = MOODS[moodKey];
-  const handle = config.getHandle();
 
   // Update presence with mood via context
   await store.heartbeat(handle, config.getOneLiner(), { mood: emoji });

package/tools/streak.js

@@ -0,0 +1,147 @@
+/**
+ * vibe_streak — View and track your building streak
+ *
+ * Streaks drive retention through daily habit formation.
+ *
+ * Badge Tiers:
+ * - 7 days: Verified Builder
+ * - 14 days: Consistent Builder
+ * - 30 days: Dedicated Builder
+ * - 60 days: Relentless Builder
+ * - 100 days: Legendary Builder
+ *
+ * Streak Freezes:
+ * - Earn 1 freeze every 7 days (max 3)
+ * - Auto-used if you miss a day
+ */
+
+const config = require('../config');
+
+const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+const definition = {
+  name: 'vibe_streak',
+  description: 'View your building streak, badges, and freezes',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      user: {
+        type: 'string',
+        description: 'Username to check (default: yourself)'
+      }
+    }
+  }
+};
+
+function requireInit() {
+  if (!config.isInitialized()) {
+    throw new Error('Not initialized. Run `vibe init` first.');
+  }
+}
+
+async function handler(args) {
+  requireInit();
+
+  const myHandle = config.getHandle();
+  const targetUser = args.user ? args.user.toLowerCase().replace('@', '') : myHandle;
+  const isOwnStreak = targetUser === myHandle.toLowerCase();
+
+  try {
+    const endpoint = `${API_URL}/api/growth/streak?user=${targetUser}`;
+    const response = await fetch(endpoint);
+    const data = await response.json();
+
+    if (!data.success) {
+      return { display: `\u274c Failed to load streak: ${data.error}` };
+    }
+
+    const streak = data.streak;
+    let display = '';
+
+    // Header with current streak
+    if (isOwnStreak) {
+      display += `## Your Building Streak\n\n`;
+    } else {
+      display += `## @${targetUser}'s Building Streak\n\n`;
+    }
+
+    // Big streak number with fire emoji based on length
+    const fireEmoji = streak.current >= 30 ? '\ud83d\udd25\ud83d\udd25\ud83d\udd25' :
+                      streak.current >= 14 ? '\ud83d\udd25\ud83d\udd25' :
+                      streak.current >= 7 ? '\ud83d\udd25' : '\ud83d\udcaa';
+
+    display += `### ${fireEmoji} ${streak.current} Day Streak\n\n`;
+
+    // Status indicators
+    if (streak.atRisk) {
+      display += `\u26a0\ufe0f **AT RISK** - Ship something today to keep your streak!\n\n`;
+    } else if (streak.isActiveToday) {
+      display += `\u2705 **Active today** - streak is safe!\n\n`;
+    }
+
+    // Stats
+    display += `| Stat | Value |\n`;
+    display += `|------|-------|\n`;
+    display += `| Current Streak | ${streak.current} days |\n`;
+    display += `| Longest Streak | ${streak.longest} days |\n`;
+    display += `| Freezes Available | ${data.freezesAvailable}\u2744\ufe0f |\n`;
+    display += `| Freezes Used | ${streak.freezesUsed || 0} |\n\n`;
+
+    // Current tier
+    if (streak.tier?.current) {
+      display += `### Current Tier: ${streak.tier.current.emoji} ${streak.tier.current.label}\n\n`;
+    }
+
+    // Next badge progress
+    if (data.nextBadge) {
+      const progress = Math.round((streak.current / data.nextBadge.daysAway + streak.current) * 100);
+      display += `### Next Badge: ${data.nextBadge.emoji} ${data.nextBadge.label}\n`;
+      display += `**${data.nextBadge.daysAway} days** to unlock\n\n`;
+    } else if (streak.current >= 100) {
+      display += `### \ud83c\udf1f All badges unlocked! You're a legend.\n\n`;
+    }
+
+    // Earned badges
+    if (streak.badges && streak.badges.length > 0) {
+      display += `### Earned Badges\n`;
+      const badgeInfo = {
+        verified_builder: { emoji: '\u2705', label: 'Verified Builder (7d)' },
+        consistent_builder: { emoji: '\ud83d\udcaa', label: 'Consistent Builder (14d)' },
+        dedicated_builder: { emoji: '\ud83d\udd25', label: 'Dedicated Builder (30d)' },
+        relentless_builder: { emoji: '\u26a1', label: 'Relentless Builder (60d)' },
+        legendary_builder: { emoji: '\ud83d\udc51', label: 'Legendary Builder (100d)' }
+      };
+
+      for (const badge of streak.badges) {
+        const info = badgeInfo[badge] || { emoji: '\ud83c\udfc5', label: badge };
+        display += `- ${info.emoji} ${info.label}\n`;
+      }
+      display += '\n';
+    }
+
+    // 30-day calendar visualization
+    if (data.calendar) {
+      display += `### Last 30 Days\n`;
+      display += '`';
+      for (const day of data.calendar) {
+        display += day.active ? '\u25a0' : '\u25a1';
+      }
+      display += '`\n';
+      display += '_(\u25a0 = active day)_\n';
+    }
+
+    // Tip for maintaining streak
+    if (isOwnStreak && !streak.isActiveToday) {
+      display += `\n---\n**Tip:** Ship something or post to the board to record today's activity!`;
+    }
+
+    return { display };
+
+  } catch (e) {
+    return {
+      display: `## Building Streak\n\n\u274c **Failed to load**\n\nError: ${e.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/stuck.js

@@ -0,0 +1,297 @@
+/**
+ * vibe stuck — The Help Signal
+ *
+ * "I'm stuck" → broadcast to the network → someone helps → karma flows
+ *
+ * Commands:
+ * - vibe stuck                     → See who needs help
+ * - vibe stuck "I'm stuck on X"   → Ask for help
+ * - vibe stuck offer @user        → Offer to help someone
+ * - vibe stuck resolve @helper    → Mark resolved, give karma
+ *
+ * This is the symbiosis layer. Helping others is how the rainforest grows.
+ */
+
+const config = require('../config');
+const { requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_stuck',
+  description: 'Ask for help when stuck, see who needs help, or offer to help. The symbiosis layer of /vibe.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['browse', 'ask', 'offer', 'resolve', 'karma'],
+        description: 'Action: browse (see requests), ask (request help), offer (help someone), resolve (mark solved), karma (see helpers)'
+      },
+      problem: {
+        type: 'string',
+        description: 'What you need help with (for ask action)'
+      },
+      context: {
+        type: 'string',
+        description: 'Additional context like file, error message (for ask action)'
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Tags like "react", "auth", "debugging" (for ask action)'
+      },
+      urgency: {
+        type: 'string',
+        enum: ['low', 'normal', 'high'],
+        description: 'How urgent is this? (default: normal)'
+      },
+      handle: {
+        type: 'string',
+        description: 'Handle to offer help to or give karma to (for offer/resolve)'
+      },
+      helpId: {
+        type: 'string',
+        description: 'Help request ID (for offer/resolve)'
+      },
+      message: {
+        type: 'string',
+        description: 'Optional message with your offer or thanks'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const myHandle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+  const action = args.action || (args.problem ? 'ask' : 'browse');
+
+  try {
+    // BROWSE — See who needs help
+    if (action === 'browse') {
+      const response = await fetch(`${apiUrl}/api/help?limit=10`);
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      if (data.count === 0) {
+        return {
+          display: `## 🌿 All Clear
+
+No one needs help right now. Everyone's in flow!
+
+**Want to help when someone does?**
+Check back later or watch for 🆘 signals in presence.
+
+**Stuck on something yourself?**
+\`vibe stuck "describe your problem"\``
+        };
+      }
+
+      let display = `## 🙋 Help Wanted\n\n`;
+      display += `${data.count} builder${data.count === 1 ? '' : 's'} could use a hand:\n\n`;
+
+      for (const req of data.requests) {
+        const urgencyIcon = req.urgency === 'high' ? '🔴' : req.urgency === 'low' ? '🟢' : '🟡';
+        display += `---\n\n`;
+        display += `${urgencyIcon} **@${req.handle}** — ${req.age}\n`;
+        display += `> ${req.problem}\n`;
+        if (req.context) {
+          display += `_Context: ${req.context}_\n`;
+        }
+        if (req.tags?.length > 0) {
+          display += `Tags: ${req.tags.map(t => `\`${t}\``).join(' ')}\n`;
+        }
+        if (req.offers?.length > 0) {
+          display += `💬 ${req.offers.length} offer${req.offers.length === 1 ? '' : 's'}\n`;
+        }
+        display += `\n→ \`vibe stuck offer --helpId "${req.id}"\`\n\n`;
+      }
+
+      display += `---\n\n`;
+      display += `_Helping others earns karma. Karma is visible on profiles._`;
+
+      return { display };
+    }
+
+    // ASK — Request help
+    if (action === 'ask') {
+      if (!args.problem) {
+        return {
+          display: `## 🆘 Ask for Help
+
+**Basic:**
+\`vibe stuck "I'm stuck on authentication"\`
+
+**With context:**
+\`vibe stuck "Getting CORS errors" --context "fetch to /api/data" --tags cors,api\`
+
+**High urgency:**
+\`vibe stuck "Production is down" --urgency high\`
+
+Your request will be visible to others who can help.
+When resolved, you can give karma to the helper.`
+        };
+      }
+
+      const response = await fetch(`${apiUrl}/api/help`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          handle: myHandle,
+          problem: args.problem,
+          context: args.context,
+          tags: args.tags,
+          urgency: args.urgency || 'normal'
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      return {
+        display: `## 🆘 Help Signal Sent!
+
+**Your request:**
+> ${args.problem}
+
+Others can now see you need help. They'll DM you if they can assist.
+
+Your presence now shows 🆘 so people know you're stuck.
+
+**When you get unstuck:**
+\`vibe stuck resolve --helpId "${data.id}" --handle @helper\`
+
+This gives karma to whoever helped you. 🌟`
+      };
+    }
+
+    // OFFER — Offer to help someone
+    if (action === 'offer') {
+      if (!args.helpId && !args.handle) {
+        // Show help requests to choose from
+        const response = await fetch(`${apiUrl}/api/help?limit=5`);
+        const data = await response.json();
+
+        if (!data.success || data.count === 0) {
+          return { display: `No active help requests right now. Check back later! 🌿` };
+        }
+
+        let display = `## 🤝 Offer Help\n\n`;
+        display += `Choose someone to help:\n\n`;
+
+        for (const req of data.requests) {
+          display += `**@${req.handle}**: ${req.problem.slice(0, 60)}${req.problem.length > 60 ? '...' : ''}\n`;
+          display += `→ \`vibe stuck offer --helpId "${req.id}"\`\n\n`;
+        }
+
+        return { display };
+      }
+
+      const response = await fetch(`${apiUrl}/api/help`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          action: 'offer',
+          handle: myHandle,
+          helpId: args.helpId,
+          message: args.message
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      return {
+        display: `## 🤝 Offer Sent!
+
+They'll get a DM that you want to help.
+
+**Start the conversation:**
+\`vibe dm @them "Hey, happy to help with that!"\`
+
+When they get unstuck, they can give you karma. 🌟`
+      };
+    }
+
+    // RESOLVE — Mark as resolved and give karma
+    if (action === 'resolve') {
+      if (!args.helpId) {
+        return {
+          display: `## ✅ Resolve Help Request
+
+**Usage:**
+\`vibe stuck resolve --helpId "help_xxx" --handle @helper\`
+
+This marks your request as solved and gives karma to whoever helped.
+
+**With a thank you message:**
+\`vibe stuck resolve --helpId "help_xxx" --handle @helper --message "Couldn't have done it without you!"\``
+        };
+      }
+
+      const response = await fetch(`${apiUrl}/api/help`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          action: 'resolve',
+          handle: myHandle,
+          helpId: args.helpId,
+          resolvedBy: args.handle,
+          thanks: args.message
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      let display = `## 🎉 Resolved!\n\n`;
+      if (data.karmaAwarded && args.handle) {
+        display += `**@${args.handle.replace('@', '')}** earned helper karma! 🌟\n\n`;
+        display += `They'll get a thank-you DM from you.\n\n`;
+      }
+      display += `Glad you got unstuck. Back to flow! 🌿`;
+
+      return { display };
+    }
+
+    // KARMA — See helper leaderboard
+    if (action === 'karma') {
+      return {
+        display: `## 🌟 Helper Karma
+
+Karma is earned when you help someone and they mark it resolved.
+
+**How it works:**
+1. Someone posts \`vibe stuck "problem"\`
+2. You offer to help: \`vibe stuck offer --helpId xxx\`
+3. You help them (DM, pair, etc.)
+4. They resolve: \`vibe stuck resolve --helpId xxx --handle @you\`
+5. You earn karma!
+
+_Karma leaderboard coming soon._
+_For now, karma is tracked and will appear on profiles._`
+      };
+    }
+
+    return { display: 'Unknown action. Use: browse, ask, offer, resolve, karma' };
+
+  } catch (error) {
+    return { display: `## Error\n\n${error.message}` };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/subscribe.js

@@ -0,0 +1,148 @@
+/**
+ * vibe_subscribe - Subscribe to a creator
+ *
+ * Subscribe to a creator's plan to access their subscriber-only content.
+ * Creates a subscription record and grants access to exclusive sessions.
+ *
+ * Examples:
+ * - "subscribe to @creator"
+ * - "join @creator's monthly plan"
+ * - "subscribe to seth"
+ */
+
+const fetch = require('node-fetch');
+const config = require('../config');
+
+const definition = {
+  name: 'vibe_subscribe',
+  description: 'Subscribe to a creator to access their subscriber-only content.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      creator_handle: {
+        type: 'string',
+        description: 'Handle of the creator to subscribe to (e.g., @seth or seth)'
+      },
+      plan_id: {
+        type: 'string',
+        description: 'Specific plan ID (optional - defaults to creator\'s default plan)'
+      }
+    },
+    required: ['creator_handle']
+  }
+};
+
+async function handler(args) {
+  const { creator_handle, plan_id } = args;
+
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  const handle = config.getHandle();
+  const token = config.getToken();
+  const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+  // Normalize creator handle
+  const normalizedCreator = creator_handle.replace(/^@/, '').toLowerCase();
+
+  if (normalizedCreator === handle.toLowerCase()) {
+    return {
+      display: '❌ You cannot subscribe to yourself'
+    };
+  }
+
+  try {
+    let targetPlanId = plan_id;
+
+    // First, check available plans if no plan_id specified
+    if (!targetPlanId) {
+      const plansResponse = await fetch(
+        `${apiUrl}/api/subscriptions/plans?creator_handle=${encodeURIComponent(normalizedCreator)}`,
+        {
+          headers: token ? {
+            'Authorization': `Bearer ${token}`
+          } : {}
+        }
+      );
+
+      const plansResult = await plansResponse.json();
+
+      if (!plansResponse.ok) {
+        return {
+          display: `❌ ${plansResult.error || 'Failed to fetch creator plans'}`
+        };
+      }
+
+      if (!plansResult.plans || plansResult.plans.length === 0) {
+        return {
+          display: `❌ @${normalizedCreator} doesn't have any subscription plans yet`
+        };
+      }
+
+      // Use default or first plan
+      const defaultPlan = plansResult.plans.find(p => p.is_default) || plansResult.plans[0];
+      targetPlanId = defaultPlan.id;
+    }
+
+    // Subscribe to the plan
+    const response = await fetch(
+      `${apiUrl}/api/subscriptions/subscribe`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          plan_id: targetPlanId
+        })
+      }
+    );
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      let display = `❌ ${result.error || 'Failed to subscribe'}`;
+      if (result.action) {
+        display += `\n\nNext step: ${result.action}`;
+      }
+      return { display };
+    }
+
+    const periodEnd = new Date(result.subscription.period_end);
+    const formattedEnd = periodEnd.toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      year: 'numeric'
+    });
+
+    return {
+      display: `
+🎉 Subscribed to @${normalizedCreator}!
+
+Plan: ${result.plan_name}
+Price: ${result.price_display}
+Period: ${result.billing_period}
+Renews: ${formattedEnd}
+
+You now have access to:
+  ⭐ All subscriber-only sessions
+  ⭐ Exclusive content
+  ⭐ Direct creator support
+
+To cancel: vibe subscriptions → cancel
+      `.trim(),
+      data: result
+    };
+
+  } catch (error) {
+    return {
+      display: `❌ Failed to subscribe: ${error.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };