slashvibe-mcp 0.3.20 → 0.3.21

package/tools/plan.js

@@ -0,0 +1,225 @@
+/**
+ * vibe_plan — Create a plan and request approval
+ *
+ * Plans are structured proposals that can be sent for async approval.
+ * They're artifacts with an approval workflow built in.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+const definition = {
+  name: 'vibe_plan',
+  description: 'Create a plan and request approval from collaborators. Plans are structured proposals with summary, problem, changes, and impact.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      title: {
+        type: 'string',
+        description: 'Plan title (e.g., "Refactor auth system", "CLAUDE.md cleanup")'
+      },
+      summary: {
+        type: 'string',
+        description: 'One-line summary of what this plan does'
+      },
+      problem: {
+        type: 'string',
+        description: 'What problem does this solve? (optional)'
+      },
+      changes: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'List of proposed changes'
+      },
+      impact: {
+        type: 'string',
+        description: 'What will be affected by this change? (optional)'
+      },
+      request_approval_from: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Handles to request approval from (e.g., ["@brightseth", "@alice"])'
+      },
+      requires: {
+        type: 'string',
+        enum: ['any', 'all'],
+        description: 'Require approval from any one person (default) or all of them'
+      }
+    },
+    required: ['title', 'summary', 'changes', 'request_approval_from']
+  }
+};
+
+// Generate artifact ID and slug
+function generateArtifactId() {
+  return `plan_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+}
+
+function generateSlug(title) {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .substring(0, 60);
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const {
+    title,
+    summary,
+    problem,
+    changes,
+    impact,
+    request_approval_from,
+    requires = 'any'
+  } = args;
+
+  const creator = config.getHandle();
+
+  // Validate approvers
+  if (!request_approval_from || request_approval_from.length === 0) {
+    return {
+      display: '❌ Must specify at least one approver in request_approval_from'
+    };
+  }
+
+  // Normalize approver handles
+  const approvers = request_approval_from.map(h => normalizeHandle(h));
+
+  // Build content blocks for the plan
+  const blocks = [
+    { type: 'summary', data: { text: summary } }
+  ];
+
+  if (problem) {
+    blocks.push({ type: 'problem', data: { text: problem } });
+  }
+
+  blocks.push({
+    type: 'proposed_changes',
+    data: { items: changes }
+  });
+
+  if (impact) {
+    blocks.push({ type: 'impact', data: { text: impact } });
+  }
+
+  // Build the plan artifact
+  const planId = generateArtifactId();
+  const slug = generateSlug(title);
+
+  // Build audience list (creator + all approvers)
+  const audience = new Set([creator, ...approvers]);
+
+  const plan = {
+    id: planId,
+    slug,
+    title,
+    template: 'plan',
+    content: { blocks },
+
+    // Social metadata
+    created_by: creator,
+    created_for: approvers[0],  // Primary approver
+    thread_id: null,
+
+    // Privacy - plans are unlisted by default
+    visibility: 'unlisted',
+    audience: Array.from(audience),
+
+    // Provenance
+    provenance: {
+      source_type: 'manual',
+      personalized_for: null,
+      notes: null
+    },
+
+    // Lifecycle
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    expires_at: null,
+
+    // Evolution
+    revision: 1,
+    forked_from: null,
+
+    // Approval workflow
+    approval: {
+      status: 'pending',
+      requested_from: approvers,
+      requires,
+      responses: [],
+      resolved_at: null
+    }
+  };
+
+  // Store the plan
+  const storeResult = await store.createArtifact(plan);
+
+  if (!storeResult.success) {
+    return {
+      display: `❌ Failed to create plan: ${storeResult.error}`
+    };
+  }
+
+  const planUrl = `https://slashvibe.dev/a/${slug}`;
+
+  // Send DM to each approver
+  const dmResults = [];
+  for (const approver of approvers) {
+    try {
+      const dmResult = await store.sendMessage(creator, approver,
+        `📋 **Plan: ${title}**\n\n` +
+        `**Summary:** ${summary}\n\n` +
+        (problem ? `**Problem:** ${problem}\n\n` : '') +
+        `**Changes:**\n${changes.map(c => `• ${c}`).join('\n')}\n\n` +
+        (impact ? `**Impact:** ${impact}\n\n` : '') +
+        `---\n` +
+        `👍 Approve · 🔄 Request changes · ❌ Reject\n` +
+        `Use: \`vibe approve ${slug}\` or \`vibe approve ${slug} --reject\``,
+        {
+          type: 'plan_card',
+          plan_id: planId,
+          plan_slug: slug,
+          plan_url: planUrl
+        }
+      );
+      dmResults.push({ approver, success: dmResult.success });
+    } catch (error) {
+      console.error(`[PLAN] Failed to DM ${approver}:`, error);
+      dmResults.push({ approver, success: false, error: error.message });
+    }
+  }
+
+  // Build response
+  const successfulDMs = dmResults.filter(r => r.success).length;
+  const approverList = approvers.map(a => `@${a}`).join(', ');
+
+  let display = `📋 **Plan created: ${title}**\n\n`;
+  display += `**Status:** ⏳ Pending approval\n`;
+  display += `**Requested from:** ${approverList}\n`;
+  display += `**Requires:** ${requires === 'all' ? 'All approvers' : 'Any approver'}\n\n`;
+
+  if (successfulDMs === approvers.length) {
+    display += `✓ Sent to ${successfulDMs} approver${successfulDMs > 1 ? 's' : ''}\n`;
+  } else {
+    display += `⚠️ Sent to ${successfulDMs}/${approvers.length} approvers\n`;
+  }
+
+  display += `\n**Plan ID:** \`${slug}\``;
+
+  return {
+    display,
+    plan_id: planId,
+    plan_slug: slug,
+    plan_url: planUrl,
+    approval_status: 'pending',
+    approvers
+  };
+}
+
+module.exports = { definition, handler };

package/tools/proof-of-work.js

@@ -0,0 +1,144 @@
+/**
+ * vibe_proof_of_work - Get unified proof-of-work summary for a user
+ *
+ * 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, normalizeHandle, displayHandle, header, divider, emptyState, formatTimeAgo } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
+
+const BASE_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+const definition = {
+  name: 'vibe_proof_of_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: 'User handle to look up (default: yourself)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const targetHandle = normalizeHandle(args.handle) || config.getHandle();
+
+  try {
+    const response = await fetch(`${BASE_URL}/api/proof-of-work?handle=${encodeURIComponent(targetHandle)}`);
+    const data = await response.json();
+
+    if (!data.success) {
+      return { display: `❌ ${data.error || 'Failed to fetch proof-of-work'}` };
+    }
+
+    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`;
+      }
+    }
+    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';
+    }
+
+    // ━━━ 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`;
+    }
+
+    // CTA for self
+    if (isSelf) {
+      display += divider();
+      display += '💡 **Boost your score:** Complete gigs (+50), sell artifacts (+30), share sessions (+10)\n';
+    }
+
+    // Build result with tip actions
+    const result = { display };
+    result.actions = formatActions(actions.afterProofOfWork(targetHandle, isSelf));
+
+    return result;
+
+  } catch (e) {
+    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/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`;