slashvibe-mcp 0.2.8 → 0.3.13

package/tools/earnings.js

@@ -0,0 +1,126 @@
+/**
+ * vibe_earnings - View unified earnings dashboard
+ *
+ * Shows all revenue sources aggregated:
+ * - Artifact sales
+ * - Session PPV revenue
+ * - Subscription revenue
+ * - Gig completions
+ * - Tips received
+ * - On-chain balance
+ *
+ * Examples:
+ * - "vibe earnings"
+ * - "show my earnings"
+ * - "how much have I made"
+ */
+
+const fetch = require('node-fetch');
+const config = require('../config');
+
+const definition = {
+  name: 'vibe_earnings',
+  description: 'View your unified earnings dashboard - artifact sales, session PPV, subscriptions, gigs, tips, and on-chain balance.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Handle to check earnings for (defaults to your handle)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const { handle } = args;
+
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  const targetHandle = handle || config.getHandle();
+  const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+  const token = config.getToken();
+
+  try {
+    const response = await fetch(
+      `${apiUrl}/api/earnings?handle=${encodeURIComponent(targetHandle)}`,
+      {
+        headers: token ? {
+          'Authorization': `Bearer ${token}`
+        } : {}
+      }
+    );
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      return {
+        display: `❌ ${result.error || 'Failed to fetch earnings'}`
+      };
+    }
+
+    const { earnings, total_earned_display, pending_display, on_chain } = result;
+
+    let formatted = `
+┌────────────────────────────────────────────────────────────┐
+│                    💰 EARNINGS DASHBOARD                   │
+│                       @${targetHandle.padEnd(33)}│
+├────────────────────────────────────────────────────────────┤
+│                                                            │
+│  Total Earned: ${(total_earned_display || '$0').padEnd(40)} │
+│  Pending (On-chain): ${(pending_display || '$0').padEnd(34)} │
+│                                                            │
+├────────────────────────────────────────────────────────────┤
+│  📊 Breakdown by Source:                                   │
+│                                                            │
+│  Artifacts:  ${(earnings.artifacts.revenue_display || '$0').padEnd(15)} (${earnings.artifacts.sales || 0} sales)${' '.repeat(17)} │
+│  Sessions:   ${(earnings.sessions.revenue_display || '$0').padEnd(15)} (${earnings.sessions.ppv_sales || 0} PPV)${' '.repeat(18)} │
+│  Gigs:       ${(earnings.gigs.revenue_display || '$0').padEnd(15)} (${earnings.gigs.completed || 0} completed)${' '.repeat(12)} │
+│  Tips:       ${(earnings.tips.revenue_display || '$0').padEnd(15)} (${earnings.tips.received || 0} received)${' '.repeat(13)} │
+│                                                            │
+`.trim();
+
+    if (on_chain) {
+      formatted += `
+├────────────────────────────────────────────────────────────┤
+│  ⛓️ On-Chain Status:                                       │`;
+
+      if (on_chain.registered) {
+        const walletDisplay = on_chain.wallet
+          ? `${on_chain.wallet.slice(0, 10)}...${on_chain.wallet.slice(-8)}`
+          : 'not set';
+        formatted += `
+│                                                            │
+│  Registered: Yes                                           │
+│  Wallet: ${walletDisplay.padEnd(47)} │
+│  Balance: ${(on_chain.balance_eth + ' ETH').padEnd(46)} │`;
+        if (on_chain.can_withdraw) {
+          formatted += `
+│  ✅ Ready to withdraw                                       │`;
+        }
+      } else {
+        formatted += `
+│                                                            │
+│  Registered: No                                            │
+│  ⚠️ Register to receive payments: vibe register_onchain    │`;
+      }
+    }
+
+    formatted += `
+│                                                            │
+└────────────────────────────────────────────────────────────┘`;
+
+    return { display: formatted, data: result };
+
+  } catch (error) {
+    return {
+      display: `❌ Failed to fetch earnings: ${error.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/feed.js

@@ -13,7 +13,8 @@
  */
 
 const config = require('../config');
-const { requireInit, header, emptyState, formatTimeAgo, divider } = require('./_shared');
+const { requireInit, header, emptyState, formatTimeAgo, divider, fetchRelevantUsers } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
 
 const definition = {
   name: 'vibe_feed',
@@ -100,8 +101,27 @@ async function handler(args) {
       );
     }
 
-    // Sort by timestamp (newest first)
-    entries.sort((a, b) => b.timestamp - a.timestamp);
+    // Fetch relevant users to personalize feed
+    // Content from relevant users gets a time boost (appears more recent)
+    const relevantHandles = new Set();
+    try {
+      const relevancy = await fetchRelevantUsers(myHandle, 'feed', 20);
+      if (relevancy && relevancy.matches) {
+        relevancy.matches.forEach(m => relevantHandles.add(m.handle.toLowerCase()));
+      }
+    } catch (e) {
+      // Don't fail feed if relevancy fails
+      console.log('[feed] relevancy fetch error:', e.message);
+    }
+
+    // Sort by timestamp with relevancy boost
+    // Relevant users get a 6-hour boost (their content appears "more recent")
+    const RELEVANCY_BOOST_MS = 6 * 60 * 60 * 1000; // 6 hours in ms
+    entries.sort((a, b) => {
+      const aBoost = relevantHandles.has(a.author.toLowerCase()) ? RELEVANCY_BOOST_MS : 0;
+      const bBoost = relevantHandles.has(b.author.toLowerCase()) ? RELEVANCY_BOOST_MS : 0;
+      return (b.timestamp + bBoost) - (a.timestamp + aBoost);
+    });
 
     // Limit
     entries = entries.slice(0, limit);
@@ -186,7 +206,18 @@ async function handler(args) {
       display += `   _${timeAgo}_\n\n`;
     });
 
-    return { display };
+    // Build response with tip actions if we have ships
+    const response = { display };
+
+    // Find the most recent ship to offer tip action for
+    const recentShip = entries.find(e => e.category === 'shipped');
+    if (recentShip && recentShip.author.toLowerCase() !== myHandle.toLowerCase()) {
+      response.actions = formatActions(actions.afterShipView(recentShip));
+      response.hint = 'tip_ship_available';
+      response.ship_author = recentShip.author;
+    }
+
+    return response;
 
   } catch (error) {
     return { display: `⚠️ Failed to load feed: ${error.message}` };

package/tools/follow.js

@@ -0,0 +1,224 @@
+/**
+ * vibe follow — Follow/unfollow creators
+ *
+ * Commands:
+ * - follow @handle        → Follow a creator
+ * - unfollow @handle      → Unfollow a creator
+ * - following             → See who you follow (+ their live status)
+ * - followers             → See who follows you
+ */
+
+const config = require('../config');
+const { requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_follow',
+  description: 'Follow creators to get notified when they go live. Unfollow, see who you follow, see your followers.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['follow', 'unfollow', 'following', 'followers'],
+        description: 'Action: follow, unfollow, following, or followers'
+      },
+      handle: {
+        type: 'string',
+        description: 'Handle to follow/unfollow (e.g., @creator)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const myHandle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+  const action = args.action || 'following';
+  const targetHandle = args.handle?.replace('@', '').toLowerCase();
+
+  try {
+    // FOLLOW
+    if (action === 'follow') {
+      if (!targetHandle) {
+        return { display: '⚠️ Specify who to follow: `vibe follow @handle`' };
+      }
+
+      const response = await fetch(`${apiUrl}/api/follow`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          follower: myHandle,
+          following: targetHandle
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      if (data.action === 'followed') {
+        let display = `✅ Now following **@${targetHandle}**\n\n`;
+        display += `You'll be notified when they go live.\n\n`;
+        display += `_You follow ${data.counts.youAreFollowing} creators_`;
+        return { display };
+      } else {
+        return { display: `Already following @${targetHandle}` };
+      }
+    }
+
+    // UNFOLLOW
+    if (action === 'unfollow') {
+      if (!targetHandle) {
+        return { display: '⚠️ Specify who to unfollow: `vibe unfollow @handle`' };
+      }
+
+      const response = await fetch(`${apiUrl}/api/follow`, {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          follower: myHandle,
+          following: targetHandle
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      let display = `✅ Unfollowed **@${targetHandle}**\n\n`;
+      display += `_You follow ${data.counts.youAreFollowing} creators_`;
+      return { display };
+    }
+
+    // FOLLOWING (who I follow)
+    if (action === 'following') {
+      const response = await fetch(`${apiUrl}/api/following?handle=${myHandle}`);
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      if (data.following.length === 0) {
+        let display = `## Following\n\n`;
+        display += `_You're not following anyone yet._\n\n`;
+        display += `**Discover creators:**\n`;
+        display += `- \`vibe discover\` — Find recommended creators\n`;
+        display += `- \`vibe follow @handle\` — Follow someone`;
+        return { display };
+      }
+
+      let display = `## Following (${data.count})\n\n`;
+
+      // Group by status
+      const live = data.following.filter(f => f.isLive);
+      const scheduled = data.following.filter(f => !f.isLive && f.nextScheduled);
+      const other = data.following.filter(f => !f.isLive && !f.nextScheduled);
+
+      if (live.length > 0) {
+        display += `**🔴 Live Now**\n`;
+        for (const f of live) {
+          display += `• **@${f.handle}** — [Watch](https://slashvibe.dev/watch/${f.roomId})\n`;
+        }
+        display += `\n`;
+      }
+
+      if (scheduled.length > 0) {
+        display += `**📅 Upcoming**\n`;
+        for (const f of scheduled) {
+          const when = formatScheduledTime(f.nextScheduled.scheduledFor);
+          display += `• **@${f.handle}** — ${f.nextScheduled.title} (${when})\n`;
+        }
+        display += `\n`;
+      }
+
+      if (other.length > 0) {
+        display += `**Following**\n`;
+        for (const f of other) {
+          const followers = f.followerCount > 0 ? ` (${f.followerCount} followers)` : '';
+          display += `• @${f.handle}${followers}\n`;
+        }
+      }
+
+      return { display };
+    }
+
+    // FOLLOWERS (who follows me)
+    if (action === 'followers') {
+      const response = await fetch(`${apiUrl}/api/followers?handle=${myHandle}`);
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      if (data.followers.length === 0) {
+        let display = `## Followers\n\n`;
+        display += `_No followers yet._\n\n`;
+        display += `**Build your audience:**\n`;
+        display += `- Go live: \`vibe broadcast start\`\n`;
+        display += `- Share what you're building\n`;
+        display += `- Engage with other creators`;
+        return { display };
+      }
+
+      let display = `## Followers (${data.count})\n\n`;
+
+      // Show active vs inactive
+      const active = data.followers.filter(f => f.isActive);
+      const inactive = data.followers.filter(f => !f.isActive);
+
+      if (active.length > 0) {
+        display += `**🟢 Active Now**\n`;
+        for (const f of active) {
+          const building = f.building ? ` — ${f.building}` : '';
+          display += `• @${f.handle}${building}\n`;
+        }
+        display += `\n`;
+      }
+
+      if (inactive.length > 0) {
+        display += `**Followers**\n`;
+        for (const f of inactive.slice(0, 20)) {
+          display += `• @${f.handle}\n`;
+        }
+        if (inactive.length > 20) {
+          display += `_...and ${inactive.length - 20} more_\n`;
+        }
+      }
+
+      return { display };
+    }
+
+    return { display: 'Unknown action. Use: follow, unfollow, following, followers' };
+
+  } catch (error) {
+    return { display: `## Error\n\n${error.message}` };
+  }
+}
+
+function formatScheduledTime(isoString) {
+  const date = new Date(isoString);
+  const now = new Date();
+  const diffMs = date - now;
+  const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+  const diffDays = Math.floor(diffHours / 24);
+
+  if (diffDays === 0) {
+    if (diffHours <= 1) return 'in < 1 hour';
+    return `in ${diffHours} hours`;
+  } else if (diffDays === 1) {
+    return 'tomorrow';
+  } else {
+    return `in ${diffDays} days`;
+  }
+}
+
+module.exports = { definition, handler };

package/tools/friends.js

@@ -0,0 +1,207 @@
+/**
+ * vibe friends — Find your GitHub friends on /vibe
+ *
+ * Commands:
+ * - vibe friends               → Find GitHub connections on vibe
+ * - vibe friends follow        → Follow all matched friends
+ * - vibe friends follow @user  → Follow specific friend
+ *
+ * This is the Plaxo move — leverage existing social graphs
+ * to bootstrap the /vibe network.
+ */
+
+const config = require('../config');
+const { requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_friends',
+  description: 'Find your GitHub friends on /vibe and follow them. "5 of your GitHub friends are here — follow them?"',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['find', 'follow'],
+        description: 'Action: find (list GitHub friends on vibe) or follow (follow them)'
+      },
+      handle: {
+        type: 'string',
+        description: 'Specific handle to follow (optional, defaults to follow all)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const myHandle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+  const action = args.action || 'find';
+
+  try {
+    // FIND — Discover GitHub friends on vibe
+    if (action === 'find') {
+      const response = await fetch(`${apiUrl}/api/github/friends?handle=${myHandle}`);
+      const data = await response.json();
+
+      if (!data.success) {
+        if (data.error?.includes('No GitHub connection')) {
+          return {
+            display: `## Connect Your GitHub
+
+To find your GitHub friends on /vibe, you need to connect your GitHub account.
+
+**Run:**
+\`vibe init\`
+
+This will authenticate with GitHub and unlock:
+• Find friends who are already on /vibe
+• One-click follow all
+• Your GitHub username as your verified handle`
+          };
+        }
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      const { github, friends, stats, cta } = data;
+
+      // Track onboarding completion (searched for GitHub friends)
+      try {
+        await fetch(`${apiUrl}/api/onboarding/checklist`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            handle: myHandle,
+            taskId: 'find_github_friends',
+            metadata: { friendsFound: friends.length }
+          })
+        });
+      } catch (e) {
+        // Non-critical, don't fail
+      }
+
+      if (friends.length === 0) {
+        let display = `## GitHub Friends on /vibe\n\n`;
+        display += `Connected as: **${github.login}** (${github.following} following, ${github.followers} followers)\n\n`;
+        display += `_None of your GitHub connections are on /vibe yet._\n\n`;
+        display += `**Be the connector!**\n`;
+        display += `Send your friends an invite: \`vibe invite\``;
+        return { display };
+      }
+
+      let display = `## 🎉 GitHub Friends on /vibe!\n\n`;
+      display += `Connected as: **${github.login}**\n`;
+
+      if (cta) {
+        display += `\n**${cta}**\n\n`;
+      }
+
+      display += `---\n\n`;
+
+      // Group by status
+      const toFollow = friends.filter(f => !f.alreadyFollowing);
+      const alreadyFollowing = friends.filter(f => f.alreadyFollowing);
+
+      if (toFollow.length > 0) {
+        display += `### Not Yet Following\n\n`;
+        for (const friend of toFollow.slice(0, 10)) {
+          const mutual = friend.isMutualOnGithub ? ' 🤝' : '';
+          const genesis = friend.genesis ? ' ✨' : '';
+          display += `**@${friend.vibeHandle}**${genesis}${mutual}`;
+          if (friend.oneLiner) {
+            display += ` — ${friend.oneLiner}`;
+          }
+          display += `\n`;
+        }
+        if (toFollow.length > 10) {
+          display += `_...and ${toFollow.length - 10} more_\n`;
+        }
+        display += `\n`;
+      }
+
+      if (alreadyFollowing.length > 0) {
+        display += `### Already Following ✓\n\n`;
+        for (const friend of alreadyFollowing.slice(0, 5)) {
+          display += `@${friend.vibeHandle}`;
+          if (friend.oneLiner) {
+            display += ` — ${friend.oneLiner}`;
+          }
+          display += `\n`;
+        }
+        if (alreadyFollowing.length > 5) {
+          display += `_...and ${alreadyFollowing.length - 5} more_\n`;
+        }
+        display += `\n`;
+      }
+
+      display += `---\n\n`;
+      display += `**Stats:** ${stats.total_matches} friends found · ${stats.mutuals} GitHub mutuals · ${stats.already_following} already following\n\n`;
+
+      if (toFollow.length > 0) {
+        display += `**Follow all ${toFollow.length} at once:**\n`;
+        display += `\`vibe friends follow\``;
+      }
+
+      return { display };
+    }
+
+    // FOLLOW — Follow GitHub friends
+    if (action === 'follow') {
+      // If specific handle provided, follow just that one
+      const handles = args.handle ? [args.handle.replace('@', '')] : null;
+
+      const response = await fetch(`${apiUrl}/api/github/friends`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          handle: myHandle,
+          handles
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ ${data.error}` };
+      }
+
+      if (data.followed.length === 0) {
+        return {
+          display: `## All Caught Up! ✓
+
+You're already following all your GitHub friends on /vibe.
+
+**Grow the network:**
+• \`vibe invite\` — Generate invite link for friends
+• \`vibe discover\` — Find new people to follow`
+        };
+      }
+
+      let display = `## 🎉 Followed ${data.count} GitHub Friend${data.count === 1 ? '' : 's'}!\n\n`;
+
+      for (const handle of data.followed.slice(0, 10)) {
+        display += `✓ @${handle}\n`;
+      }
+
+      if (data.followed.length > 10) {
+        display += `...and ${data.followed.length - 10} more\n`;
+      }
+
+      display += `\n---\n\n`;
+      display += `**${data.message}**\n\n`;
+      display += `They'll see you in their followers. Say hi!\n`;
+      display += `\`vibe dm @${data.followed[0]} "Hey! Saw you're on /vibe too 👋"\``;
+
+      return { display };
+    }
+
+    return { display: 'Unknown action. Use: find, follow' };
+
+  } catch (error) {
+    return { display: `## Error\n\n${error.message}` };
+  }
+}
+
+module.exports = { definition, handler };