slashvibe-mcp 0.2.9 → 0.3.13

package/tools/proof-of-work.js

@@ -1,148 +1,144 @@
 /**
- * vibe proof-of-work — View your complete proof-of-work profile
+ * vibe_proof_of_work - Get unified proof-of-work summary for a user
  *
- * Shows your unified proof-of-work across PAST, PRESENT, and FUTURE:
- * - PAST: Artifacts created/sold, sessions shared, revenue
- * - PRESENT: What you're working on, live status
- * - FUTURE: Gigs completed, hire availability, reputation
- *
- * Part of /vibe's native monetization layer.
+ * Shows the complete "proof of work" picture:
+ * - PAST: Artifacts created/sold, sessions shared
+ * - PRESENT: Live presence, current work
+ * - FUTURE: Gigs completed/posted, hire availability
+ * - UNIFIED: Vibe score, tier, proven skills
  */
 
 const config = require('../config');
-const { requireInit } = require('./_shared');
+const { requireInit, normalizeHandle, displayHandle, header, divider, emptyState, formatTimeAgo } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
 
-const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+const BASE_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
 
 const definition = {
   name: 'vibe_proof_of_work',
-  description: 'View your complete proof-of-work profile: artifacts sold, gigs completed, skills proven, reputation tier. Search triggers: "proof of work", "my profile", "my reputation", "my stats", "show my work".',
+  description: 'Get proof-of-work summary for a user. Shows artifacts, sessions, gigs, vibe score, and proven skills.',
   inputSchema: {
     type: 'object',
     properties: {
       handle: {
         type: 'string',
-        description: 'Handle to view (defaults to your own). Must not include @.'
+        description: 'User handle to look up (default: yourself)'
       }
     }
   }
 };
 
-// Tier emoji mapping
-const TIER_EMOJI = {
-  newcomer: '🌱',
-  rising: '📈',
-  proven: '✅',
-  established: '⭐',
-  expert: '🏆'
-};
-
 async function handler(args) {
   const initCheck = requireInit();
   if (initCheck) return initCheck;
 
-  const handle = args.handle || config.getHandle();
-  const normalizedHandle = handle.replace('@', '').toLowerCase();
-  const isOwnProfile = normalizedHandle === config.getHandle();
+  const targetHandle = normalizeHandle(args.handle) || config.getHandle();
 
   try {
-    const response = await fetch(`${API_URL}/api/proof-of-work?handle=${encodeURIComponent(normalizedHandle)}`);
+    const response = await fetch(`${BASE_URL}/api/proof-of-work?handle=${encodeURIComponent(targetHandle)}`);
     const data = await response.json();
 
     if (!data.success) {
-      return {
-        display: `❌ Could not load proof-of-work: ${data.error || 'User not found'}`
-      };
-    }
-
-    const tierEmoji = TIER_EMOJI[data.tier] || '🌱';
-
-    let display = `## ${tierEmoji} Proof of Work: @${data.handle}\n\n`;
-
-    // Overall score and tier
-    display += `**Score:** ${data.proof_of_work_score} points\n`;
-    display += `**Tier:** ${data.tier.charAt(0).toUpperCase() + data.tier.slice(1)}\n\n`;
-
-    // PAST
-    display += `### 📚 PAST (Artifacts & Sessions)\n`;
-    display += `- Artifacts created: ${data.artifacts.created}\n`;
-    display += `- For sale: ${data.artifacts.for_sale}\n`;
-    display += `- Sold: ${data.artifacts.sold}\n`;
-    if (data.artifacts.revenue_cents > 0) {
-      display += `- Revenue: $${(data.artifacts.revenue_cents / 100).toFixed(2)}\n`;
+      return { display: `❌ ${data.error || 'Failed to fetch proof-of-work'}` };
     }
-    display += `- Sessions shared: ${data.sessions.shared}\n\n`;
 
-    // PRESENT
-    display += `### 🔴 PRESENT (Live Status)\n`;
-    display += `- Status: ${data.presence.status}\n`;
-    if (data.presence.working_on) {
-      display += `- Working on: ${data.presence.working_on}\n`;
+    const pow = data.proof_of_work;
+    const isSelf = targetHandle === config.getHandle();
+
+    // Build display
+    let display = header(`Proof of Work: ${displayHandle(targetHandle)}`, 2) + '\n\n';
+
+    // Vibe Score & Tier
+    display += `**Vibe Score:** ${pow.unified?.vibe_score || 0}\n`;
+    display += `**Tier:** ${formatTier(pow.unified?.tier)}\n\n`;
+
+    // ━━━ PAST ━━━
+    display += header('📜 PAST (Artifacts & Sessions)', 3) + '\n';
+    const past = pow.past || {};
+    display += `• **Artifacts Created:** ${past.artifacts_created || 0}\n`;
+    display += `• **Artifacts Sold:** ${past.artifacts_sold || 0}\n`;
+    display += `• **Revenue Earned:** $${((past.revenue_cents || 0) / 100).toFixed(2)}\n`;
+    display += `• **Sessions Shared:** ${past.sessions_shared || 0}\n\n`;
+
+    // ━━━ PRESENT ━━━
+    display += header('🟢 PRESENT (Live)', 3) + '\n';
+    const present = pow.present || {};
+    if (present.is_online) {
+      display += `• **Status:** Online\n`;
+      if (present.working_on) {
+        display += `• **Working on:** ${present.working_on}\n`;
+      }
+      if (present.project) {
+        display += `• **Project:** ${present.project}\n`;
+      }
+    } else {
+      display += `• **Status:** Offline\n`;
+      if (present.last_seen) {
+        display += `• **Last seen:** ${formatTimeAgo(present.last_seen)}\n`;
+      }
     }
-    if (data.presence.project) {
-      display += `- Project: ${data.presence.project}\n`;
+    display += '\n';
+
+    // ━━━ FUTURE ━━━
+    display += header('🚀 FUTURE (Gigs & Availability)', 3) + '\n';
+    const future = pow.future || {};
+    display += `• **Gigs Completed:** ${future.gigs_completed || 0}\n`;
+    display += `• **Gigs Posted:** ${future.gigs_posted || 0}\n`;
+    display += `• **Avg Rating:** ${future.avg_rating ? `${future.avg_rating.toFixed(1)}⭐` : 'No ratings yet'}\n`;
+    display += `• **Available for Hire:** ${future.available_for_hire ? 'Yes' : 'No'}\n\n`;
+
+    // ━━━ PROVEN SKILLS ━━━
+    const skills = pow.unified?.proven_skills || [];
+    if (skills.length > 0) {
+      display += header('🛠️ Proven Skills', 3) + '\n';
+      skills.slice(0, 10).forEach(skill => {
+        display += `• ${skill.name} (${skill.count} gig${skill.count !== 1 ? 's' : ''})\n`;
+      });
+      display += '\n';
     }
-    display += `\n`;
 
-    // FUTURE
-    display += `### 🚀 FUTURE (Gigs & Hire)\n`;
-    display += `- Gigs completed: ${data.gigs.completed}\n`;
-    if (data.gigs.in_progress > 0) {
-      display += `- Gigs in progress: ${data.gigs.in_progress}\n`;
-    }
-    if (data.gigs.rating_avg) {
-      display += `- Average rating: ${data.gigs.rating_avg}/5\n`;
+    // ━━━ SCORE BREAKDOWN ━━━
+    const breakdown = pow.unified?.score_breakdown;
+    if (breakdown) {
+      display += header('📊 Score Breakdown', 3) + '\n';
+      display += `• Gigs: ${breakdown.gigs || 0}\n`;
+      display += `• Artifacts: ${breakdown.artifacts || 0}\n`;
+      display += `• Sessions: ${breakdown.sessions || 0}\n`;
+      display += `• Invites: ${breakdown.invites || 0}\n`;
+      display += `• Ships: ${breakdown.ships || 0}\n`;
     }
-    display += `- Available for hire: ${data.hire.available ? 'Yes' : 'No'}\n`;
-    if (data.hire.rate) {
-      display += `- Hourly rate: $${data.hire.rate}\n`;
-    }
-    if (data.hire.skills && data.hire.skills.length > 0) {
-      display += `- Skills: ${data.hire.skills.join(', ')}\n`;
-    }
-    display += `\n`;
 
-    // Proven skills
-    const skills = Object.entries(data.proven_skills || {});
-    if (skills.length > 0) {
-      display += `### 🛠️ Proven Skills\n`;
-      skills.sort((a, b) => b[1] - a[1]);
-      skills.slice(0, 5).forEach(([skill, level]) => {
-        const bars = '█'.repeat(Math.min(level, 5)) + '░'.repeat(5 - Math.min(level, 5));
-        display += `- ${skill}: ${bars} (${level})\n`;
-      });
-      display += `\n`;
+    // CTA for self
+    if (isSelf) {
+      display += divider();
+      display += '💡 **Boost your score:** Complete gigs (+50), sell artifacts (+30), share sessions (+10)\n';
     }
 
-    // Call to action
-    display += `---\n`;
-    if (isOwnProfile) {
-      if (data.artifacts.for_sale === 0) {
-        display += `💡 **Tip:** Price your artifacts to earn from your work!\n`;
-      }
-      if (data.gigs.completed === 0) {
-        display += `💡 **Tip:** Complete gigs to boost your reputation and tier.\n`;
-      }
-    } else {
-      if (data.hire.available) {
-        display += `📩 DM @${data.handle} to discuss a project\n`;
-      }
-    }
+    // Build result with tip actions
+    const result = { display };
+    result.actions = formatActions(actions.afterProofOfWork(targetHandle, isSelf));
 
-    return {
-      display,
-      data: {
-        handle: data.handle,
-        score: data.proof_of_work_score,
-        tier: data.tier
-      }
-    };
+    return result;
 
   } catch (e) {
-    return {
-      display: `❌ Error loading proof-of-work: ${e.message}`
-    };
+    console.error('[proof-of-work] Error:', e);
+    return { display: `❌ Failed to fetch proof-of-work: ${e.message}` };
   }
 }
 
+/**
+ * Format tier with emoji
+ */
+function formatTier(tier) {
+  const tiers = {
+    newcomer: '🌱 Newcomer',
+    rising: '📈 Rising',
+    proven: '✅ Proven',
+    established: '🏆 Established',
+    expert: '⭐ Expert',
+    legendary: '👑 Legendary'
+  };
+  return tiers[tier] || tier || 'Unknown';
+}
+
 module.exports = { definition, handler };

package/tools/pulse.js

@@ -0,0 +1,218 @@
+/**
+ * vibe pulse — Lightweight presence check for inline display
+ *
+ * Returns a compact "mini card" showing who's online.
+ * Designed to be called periodically by Claude based on CLAUDE.md instructions.
+ *
+ * Unlike vibe_who (full presence), this is:
+ * - Faster (minimal data)
+ * - Compact (fits in a response footer)
+ * - Suggestive (gentle nudges to connect)
+ */
+
+const config = require('../config');
+const store = require('../store');
+
+const definition = {
+  name: 'vibe_pulse',
+  description: 'Quick presence check for inline display. Returns compact mini card showing who\'s online. Call periodically (~every 5 messages) to maintain ambient awareness.',
+  inputSchema: {
+    type: 'object',
+    properties: {}
+  }
+};
+
+// Gentle nudge templates
+const NUDGES = {
+  just_joined: [
+    "{handle} just joined — say hi?",
+    "{handle} is here! Quick wave?",
+    "New face: {handle} just arrived"
+  ],
+  shipping: [
+    "{handle} is shipping — cheer them on?",
+    "{handle} in flow mode 🔥"
+  ],
+  debugging: [
+    "{handle} debugging — maybe you can help?",
+    "{handle} stuck on something"
+  ],
+  active: [
+    "{handle} is around",
+    "{handle} building right now"
+  ],
+  multiple: [
+    "{count} builders online — you're not alone",
+    "{count} people vibing right now",
+    "Room's alive: {count} online"
+  ]
+};
+
+function pickRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function formatNudge(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(`{${key}}`, value);
+  }
+  return result;
+}
+
+function getStatusEmoji(user) {
+  // Explicit mood takes priority
+  if (user.mood === '🔥' || user.mood === 'shipping') return '🔥';
+  if (user.mood === '🐛' || user.mood === 'debugging') return '🐛';
+  if (user.mood === '🧠' || user.mood === 'thinking') return '🧠';
+  if (user.mood === '🎉' || user.mood === 'celebrating') return '🎉';
+  if (user.mood === '🎧') return '🎧';
+  if (user.mood === '☕') return '☕';
+
+  // Infer from what they're building (one_liner)
+  const workingOn = (user.one_liner || '').toLowerCase();
+  if (workingOn.includes('ai') || workingOn.includes('agent') || workingOn.includes('llm')) return '🤖';
+  if (workingOn.includes('creative') || workingOn.includes('art') || workingOn.includes('design')) return '🎨';
+  if (workingOn.includes('game') || workingOn.includes('chess') || workingOn.includes('play')) return '🎮';
+  if (workingOn.includes('social') || workingOn.includes('chat') || workingOn.includes('message')) return '💬';
+  if (workingOn.includes('crypto') || workingOn.includes('web3') || workingOn.includes('token')) return '⛓️';
+  if (workingOn.includes('tool') || workingOn.includes('platform') || workingOn.includes('infra')) return '🛠️';
+  if (workingOn.includes('mobile') || workingOn.includes('app')) return '📱';
+  if (workingOn.includes('data') || workingOn.includes('analytics')) return '📊';
+
+  // Infer from builderMode
+  if (user.builderMode === 'deep-focus') return '🧘';
+  if (user.builderMode === 'shipping') return '🚀';
+  if (user.builderMode === 'exploring') return '🔍';
+  if (user.builderMode === 'focused') return '💻';
+
+  // Fallback to recency
+  const age = Date.now() - user.lastSeen;
+  if (age < 2 * 60 * 1000) return '⚡'; // Active < 2min
+  if (age < 5 * 60 * 1000) return '●';  // Recent < 5min
+  return '○'; // Idle
+}
+
+function getUserState(user) {
+  const age = Date.now() - user.lastSeen;
+
+  // Check for just joined (< 2 min session)
+  if (user.firstSeen) {
+    const sessionDuration = (user.lastSeen - new Date(user.firstSeen).getTime()) / 60000;
+    if (sessionDuration < 2 && age < 2 * 60 * 1000) {
+      return 'just_joined';
+    }
+  }
+
+  if (user.mood === '🔥' || user.mood === 'shipping') return 'shipping';
+  if (user.mood === '🐛' || user.mood === 'debugging') return 'debugging';
+
+  return 'active';
+}
+
+async function handler(args) {
+  // Check if initialized
+  if (!config.isInitialized()) {
+    return {
+      display: null,
+      empty: true,
+      reason: 'not_initialized'
+    };
+  }
+
+  const myHandle = config.getHandle();
+
+  // Fetch presence and unread (wrap in Promise.resolve for local store compat)
+  const [users, unreadCount] = await Promise.all([
+    Promise.resolve(store.getActiveUsers()).catch(() => []),
+    Promise.resolve(store.getUnreadCount(myHandle)).catch(() => 0)
+  ]);
+
+  const others = users.filter(u => u.handle !== myHandle);
+
+  // Empty room
+  if (others.length === 0 && unreadCount === 0) {
+    return {
+      display: null,
+      empty: true,
+      reason: 'no_one_online'
+    };
+  }
+
+  // Smart truncate: break at word boundary, add ellipsis if truncated
+  function smartTruncate(text, maxLen) {
+    if (!text || text.length <= maxLen) return text || '';
+    // Find last space before maxLen
+    const truncated = text.slice(0, maxLen);
+    const lastSpace = truncated.lastIndexOf(' ');
+    if (lastSpace > maxLen * 0.6) {
+      // Break at word if we're not losing too much
+      return truncated.slice(0, lastSpace) + '…';
+    }
+    return truncated.slice(0, maxLen - 1) + '…';
+  }
+
+  // Get short status label from what they're working on
+  function getStatusLabel(user) {
+    if (user.mood === '🔥' || user.mood === 'shipping') return 'shipping';
+    if (user.mood === '🐛' || user.mood === 'debugging') return 'debugging';
+    if (user.mood === '🧠' || user.mood === 'thinking') return 'thinking';
+    if (user.mood === '🎉' || user.mood === 'celebrating') return 'shipped!';
+    if (user.mood === '👥' || user.mood === 'pairing') return 'pairing';
+    if (user.mood === '🎧') return 'vibing';
+    if (user.note) return smartTruncate(user.note, 28);
+    if (user.one_liner) return smartTruncate(user.one_liner, 28);
+    return '';
+  }
+
+  // Build compact single-line summary optimized for collapsed view
+  // This ONE line must contain all key info since details get hidden
+  const topUsers = others.slice(0, 4);
+  const userChips = topUsers.map(u => `${getStatusEmoji(u)} ${u.handle}`).join(' · ');
+  const moreCount = others.length > 4 ? ` +${others.length - 4}` : '';
+  const dmsBadge = unreadCount > 0 ? `📬 ${unreadCount} · ` : '';
+
+  // Single summary line with all key info
+  let display = `${dmsBadge}☕ ${others.length} online — ${userChips}${moreCount}`;
+
+  // Generate nudge
+  let nudge = null;
+  if (others.length > 0) {
+    // Find most interesting user for nudge
+    const states = others.map(u => ({ user: u, state: getUserState(u) }));
+
+    // Priority: just_joined > shipping > debugging > active
+    const priority = ['just_joined', 'shipping', 'debugging', 'active'];
+    let picked = null;
+
+    for (const state of priority) {
+      picked = states.find(s => s.state === state);
+      if (picked) break;
+    }
+
+    if (picked) {
+      const templates = NUDGES[picked.state] || NUDGES.active;
+      nudge = formatNudge(pickRandom(templates), {
+        handle: `@${picked.user.handle}`,
+        count: others.length
+      });
+    } else if (others.length >= 2) {
+      nudge = formatNudge(pickRandom(NUDGES.multiple), { count: others.length });
+    }
+  }
+
+  // Add nudge after details
+  if (nudge) {
+    display += `\n\n_${nudge}_`;
+  }
+
+  return {
+    display,
+    online_count: others.length,
+    unread_count: unreadCount,
+    nudge,
+    handles: others.slice(0, 5).map(u => u.handle)
+  };
+}
+
+module.exports = { definition, handler };

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

@@ -83,11 +83,11 @@ Nice try, but you can't report yourself.`
 
 ${result.error || 'Could not submit report. Please try again.'}
 
-If the problem persists, DM @seth directly.`
+If the problem persists, DM @vibe for help.`
     };
   }
 
-  let display = `## Report Submitted
+  const display = `## Report Submitted
 
 **Report ID:** ${result.report_id}
 **Reported:** @${reportedHandle}