slashvibe-mcp 0.2.2 → 0.2.4

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

@@ -0,0 +1,231 @@
+/**
+ * vibe request — Post build requests / wishes
+ *
+ * "I wish X existed" → others can claim and build
+ *
+ * Post: vibe request "I wish there was a tool for..."
+ * Claim: vibe request claim [id]
+ * Browse: vibe requests
+ */
+
+const config = require('../config');
+const { requireInit, header, emptyState, formatTimeAgo, divider } = require('./_shared');
+
+const definition = {
+  name: 'vibe_request',
+  description: 'Post a build request — something you wish existed. Others can claim and build it.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'What you wish existed (leave empty to browse requests)'
+      },
+      claim: {
+        type: 'string',
+        description: 'ID of request to claim (e.g., "req_abc123")'
+      },
+      bounty: {
+        type: 'string',
+        description: 'What you\'re offering (e.g., "feedback", "shoutout", "collab")'
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Tags for the request'
+      },
+      show: {
+        type: 'string',
+        enum: ['open', 'claimed', 'all'],
+        description: 'Filter by status (default: open)'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number to show (default: 10)'
+      }
+    }
+  }
+};
+
+const STATUS_EMOJI = {
+  'open': '🔓',
+  'claimed': '🔨',
+  'shipped': '✅'
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const apiUrl = config.getApiUrl();
+  const myHandle = config.getHandle();
+
+  // Claim a request
+  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,
+        body: JSON.stringify({
+          author: myHandle,
+          category: 'claim',
+          content: `🔨 Claimed request: ${args.claim}`,
+          tags: [`claim:${args.claim}`]
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ Failed to claim: ${data.error}` };
+      }
+
+      return {
+        display: `🔨 claimed \`${args.claim}\``
+      };
+
+    } catch (error) {
+      return { display: `⚠️ Failed to claim: ${error.message}` };
+    }
+  }
+
+  // Post a request
+  if (args.content) {
+    const content = args.content.trim();
+
+    if (content.length > 500) {
+      return { display: '⚠️ Keep requests concise (max 500 chars)' };
+    }
+
+    // Build request entry
+    const bountyText = args.bounty ? ` [bounty: ${args.bounty}]` : '';
+    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,
+        body: JSON.stringify({
+          author: myHandle,
+          category: 'request',
+          content: fullContent,
+          tags: args.tags || []
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ Failed to post request: ${data.error}` };
+      }
+
+      let display = `🔓 posted\n\n"${content}"`;
+
+      if (args.bounty) {
+        display += `\n_${args.bounty}_`;
+      }
+
+      return { display };
+
+    } catch (error) {
+      return { display: `⚠️ Failed to post: ${error.message}` };
+    }
+  }
+
+  // Browse requests
+  try {
+    const limit = Math.min(args.limit || 10, 30);
+    let url = `${apiUrl}/api/board?limit=${limit * 2}&category=request`;
+
+    // Also get claims to show status
+    const claimsUrl = `${apiUrl}/api/board?limit=50&category=claim`;
+
+    const [requestsRes, claimsRes] = await Promise.all([
+      fetch(url),
+      fetch(claimsUrl)
+    ]);
+
+    const requests = (await requestsRes.json()).entries || [];
+    const claims = (await claimsRes.json()).entries || [];
+
+    // Build claimed set
+    const claimedIds = new Set();
+    const claimers = new Map();
+    claims.forEach(c => {
+      const match = c.content.match(/Claimed request: (\S+)/);
+      if (match) {
+        claimedIds.add(match[1]);
+        claimers.set(match[1], c.author);
+      }
+    });
+
+    // Filter by status
+    let filtered = requests;
+    if (args.show === 'open') {
+      filtered = requests.filter(r => !claimedIds.has(r.id));
+    } else if (args.show === 'claimed') {
+      filtered = requests.filter(r => claimedIds.has(r.id));
+    }
+
+    if (filtered.length === 0) {
+      return {
+        display: `${header('Build Requests')}\n\n${emptyState('No requests yet...', 'Post one: "I wish [X] existed"')}`
+      };
+    }
+
+    let display = header('Build Requests');
+    if (args.show && args.show !== 'all') display += ` (${args.show})`;
+    display += '\n\n';
+
+    filtered.slice(0, limit).forEach(entry => {
+      const isClaimed = claimedIds.has(entry.id);
+      const status = isClaimed ? 'claimed' : 'open';
+      const emoji = STATUS_EMOJI[status];
+      const timeAgo = formatTimeAgo(entry.timestamp);
+      const shortId = entry.id.slice(-8);
+
+      // Parse bounty from content
+      const bountyMatch = entry.content.match(/\[bounty: ([^\]]+)\]/);
+      const bounty = bountyMatch ? bountyMatch[1] : null;
+      const cleanContent = entry.content.replace(/\[bounty: [^\]]+\]/, '').trim();
+
+      display += `${emoji} **@${entry.author}** _${timeAgo}_\n`;
+      display += `   "${cleanContent}"\n`;
+
+      if (bounty) {
+        display += `   💎 _Bounty: ${bounty}_\n`;
+      }
+
+      if (isClaimed) {
+        const claimer = claimers.get(entry.id);
+        display += `   _Claimed by @${claimer}_\n`;
+      } else {
+        display += `   \`claim ${shortId}\`\n`;
+      }
+
+      display += '\n';
+    });
+
+    return { display };
+
+  } catch (error) {
+    return { display: `⚠️ Failed to load requests: ${error.message}` };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/reservations.js

@@ -0,0 +1,116 @@
+/**
+ * vibe reservations — List active file reservations
+ *
+ * Shows who has reserved what files in the current scope.
+ */
+
+const config = require('../config');
+const reservations = require('../store/reservations');
+const { requireInit, formatTimeAgo, emptyState } = require('./_shared');
+
+const definition = {
+  name: 'vibe_reservations',
+  description: 'List active file reservations in the current project.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      active_only: {
+        type: 'boolean',
+        description: 'Only show active reservations (default: true)'
+      },
+      path_filter: {
+        type: 'string',
+        description: 'Filter by path (e.g., "src/auth")'
+      }
+    }
+  }
+};
+
+// Format remaining time
+function formatRemaining(expires_ts) {
+  const now = new Date();
+  const expires = new Date(expires_ts);
+  const ms = expires - now;
+
+  if (ms <= 0) return 'expired';
+
+  const minutes = Math.floor(ms / 60000);
+  if (minutes < 60) return `${minutes}m left`;
+
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ${minutes % 60}m left`;
+
+  return `${Math.floor(hours / 24)}d left`;
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const handle = config.getHandle();
+  const { active_only = true, path_filter } = args;
+
+  // Cleanup expired first
+  reservations.cleanup();
+
+  // Get reservations
+  const list = reservations.list({ active_only, path_filter });
+  const scope = reservations.getScope();
+
+  if (list.length === 0) {
+    let display = `## Reservations\n\n`;
+    display += `**Scope:** ${scope}\n\n`;
+    display += emptyState(
+      'No active reservations in this project.',
+      '`vibe reserve --paths ["file.ts"]` to claim files'
+    );
+    return { display };
+  }
+
+  let display = `## Reservations\n\n`;
+  display += `**Scope:** ${scope}\n\n`;
+
+  // Group by owner
+  const byOwner = {};
+  for (const r of list) {
+    if (!byOwner[r.owner]) {
+      byOwner[r.owner] = [];
+    }
+    byOwner[r.owner].push(r);
+  }
+
+  // Show own reservations first
+  const owners = Object.keys(byOwner).sort((a, b) => {
+    if (a === handle) return -1;
+    if (b === handle) return 1;
+    return a.localeCompare(b);
+  });
+
+  for (const owner of owners) {
+    const isMe = owner === handle;
+    display += `### @${owner}${isMe ? ' (you)' : ''}\n\n`;
+
+    for (const r of byOwner[owner]) {
+      const remaining = formatRemaining(r.expires_ts);
+      const exclusive = r.exclusive ? '🔒' : '📂';
+
+      display += `${exclusive} **${r.paths.map(p => `\`${p}\``).join(', ')}**\n`;
+      display += `   _${remaining}_`;
+      if (r.reason) {
+        display += ` — ${r.reason}`;
+      }
+      display += `\n`;
+      if (isMe) {
+        display += `   \`vibe release ${r.reservation_id}\` to release\n`;
+      }
+      display += `\n`;
+    }
+  }
+
+  display += `---\n`;
+  display += `${list.length} active reservation(s)`;
+
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/reserve.js

@@ -0,0 +1,111 @@
+/**
+ * vibe reserve — Claim files you're working on
+ *
+ * Advisory lock to signal edit intent.
+ * Warns on conflicts, doesn't block.
+ */
+
+const config = require('../config');
+const reservations = require('../store/reservations');
+const { requireInit, formatDuration, warning, success } = require('./_shared');
+
+const definition = {
+  name: 'vibe_reserve',
+  description: 'Reserve files you\'re working on. Advisory lock — warns on conflicts, doesn\'t block.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      paths: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Files or directories to reserve (relative paths, e.g., ["src/auth.ts", "src/api/"])'
+      },
+      ttl_seconds: {
+        type: 'number',
+        description: 'How long to hold reservation (default: 3600 = 1 hour)'
+      },
+      exclusive: {
+        type: 'boolean',
+        description: 'Warn others if they try to reserve same files (default: true)'
+      },
+      reason: {
+        type: 'string',
+        description: 'What you\'re doing (e.g., "Fix auth race condition")'
+      },
+      thread_id: {
+        type: 'string',
+        description: 'Link to a thread/task ID (optional)'
+      }
+    },
+    required: ['paths']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const handle = config.getHandle();
+  const { paths, ttl_seconds = 3600, exclusive = true, reason, thread_id } = args;
+
+  if (!paths || paths.length === 0) {
+    return {
+      display: `## Reserve Files
+
+Claim files you're working on to avoid conflicts.
+
+**Usage:**
+\`\`\`
+vibe reserve --paths ["src/auth.ts"]
+vibe reserve --paths ["src/api/"] --reason "Refactoring API layer"
+vibe reserve --paths ["*.ts"] --ttl_seconds 7200
+\`\`\`
+
+**Options:**
+- \`paths\` — Files or directories (required)
+- \`reason\` — What you're doing
+- \`ttl_seconds\` — Duration (default: 1 hour)
+- \`exclusive\` — Warn on conflicts (default: true)
+- \`thread_id\` — Link to task/thread`
+    };
+  }
+
+  // Create reservation
+  const result = reservations.create(handle, paths, {
+    ttl_seconds,
+    exclusive,
+    reason,
+    thread_id
+  });
+
+  const { reservation, conflicts } = result;
+  const duration = formatDuration(ttl_seconds * 1000);
+
+  let display = `## Reservation Created\n\n`;
+  display += `**ID:** \`${reservation.reservation_id}\`\n`;
+  display += `**Scope:** ${reservation.scope}\n`;
+  display += `**Files:** ${paths.map(p => `\`${p}\``).join(', ')}\n`;
+  display += `**Expires:** ${duration}\n`;
+  if (reason) {
+    display += `**Reason:** ${reason}\n`;
+  }
+
+  // Show conflicts as warnings
+  if (conflicts && conflicts.length > 0) {
+    display += `\n---\n\n`;
+    display += warning(`${conflicts.length} conflict(s) detected:\n\n`);
+    for (const c of conflicts) {
+      display += `- \`${c.path}\` reserved by **@${c.owner}**`;
+      if (c.reason) display += ` (${c.reason})`;
+      display += `\n`;
+    }
+    display += `\n_These are advisory warnings — you can still proceed._`;
+  }
+
+  display += `\n\n---\n`;
+  display += `\`vibe reservations\` to see all | \`vibe release ${reservation.reservation_id}\` when done`;
+
+  return { display };
+}
+
+module.exports = { definition, handler };