slashvibe-mcp 0.2.2 → 0.2.4

package/tools/genesis.js

@@ -0,0 +1,233 @@
+/**
+ * vibe_genesis - Genesis liquidity mining
+ *
+ * Deposit USDC to earn yield + Genesis multipliers
+ *
+ * Actions:
+ * - deposit: Lock USDC for yield farming
+ * - rewards: Check accumulated rewards
+ * - stats: View global Genesis stats
+ *
+ * Examples:
+ * - "vibe genesis deposit $100 for 90 days"
+ * - "check my genesis rewards"
+ * - "show genesis stats"
+ */
+
+const fetch = require('node-fetch');
+
+module.exports = {
+  name: 'vibe_genesis',
+  description: 'Genesis liquidity mining: deposit USDC to earn yield with early depositor bonuses. Base APY 5%, Genesis multipliers up to 2x, lock bonuses up to 2x.',
+
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['deposit', 'rewards', 'stats'],
+        description: 'Action to perform: deposit (add liquidity), rewards (check earnings), stats (global metrics)'
+      },
+      amount: {
+        type: 'number',
+        description: 'Amount to deposit in USD (min $10). Only for deposit action.'
+      },
+      lock_days: {
+        type: 'number',
+        enum: [0, 30, 90, 180],
+        description: 'Lock period in days: 0 (no lock), 30 (+20% APY), 90 (+50% APY), 180 (+100% APY). Only for deposit action.',
+        default: 0
+      }
+    },
+    required: ['action']
+  },
+
+  async execute({ action, amount, lock_days = 0 }, 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';
+
+      switch (action) {
+        case 'deposit': {
+          if (!amount || amount < 10) {
+            return {
+              success: false,
+              error: 'Minimum deposit is $10'
+            };
+          }
+
+          const response = await fetch(`${apiUrl}/api/genesis/deposit`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': `Bearer ${context.token}`
+            },
+            body: JSON.stringify({
+              from: handle,
+              amount,
+              lock_days
+            })
+          });
+
+          const result = await response.json();
+
+          if (!response.ok) {
+            return {
+              success: false,
+              error: result.error || 'Deposit failed',
+              details: result.details
+            };
+          }
+
+          const effectiveAPY = result.effective_apy * 100;
+          const unlockDate = result.unlock_at
+            ? new Date(result.unlock_at).toLocaleDateString()
+            : 'No lock';
+
+          return {
+            success: true,
+            message: `Deposited $${amount} to Genesis mining`,
+            deposit: {
+              deposit_id: result.deposit_id,
+              amount: `$${amount}`,
+              base_apy: `${(result.base_apy * 100).toFixed(2)}%`,
+              genesis_multiplier: `${result.genesis_multiplier}x`,
+              effective_apy: `${effectiveAPY.toFixed(2)}%`,
+              lock_days,
+              unlock_at: unlockDate,
+              current_tvl: `$${result.current_tvl.toFixed(2)}`
+            },
+            formatted: `
+💧 Genesis Deposit Successful!
+
+Amount: $${amount}
+Lock Period: ${lock_days} days
+Unlock: ${unlockDate}
+
+APY Breakdown:
+  Base: ${(result.base_apy * 100).toFixed(2)}%
+  Genesis Multiplier: ${result.genesis_multiplier}x
+  Lock Bonus: ${lock_days >= 180 ? '2.0x' : lock_days >= 90 ? '1.5x' : lock_days >= 30 ? '1.2x' : '1.0x'}
+
+  Effective APY: ${effectiveAPY.toFixed(2)}%
+
+Current TVL: $${result.current_tvl.toFixed(2)}
+
+Rewards accrue daily. Check with: vibe genesis rewards
+            `.trim()
+          };
+        }
+
+        case 'rewards': {
+          const response = await fetch(
+            `${apiUrl}/api/genesis/rewards?handle=${handle}`,
+            {
+              headers: {
+                'Authorization': `Bearer ${context.token}`
+              }
+            }
+          );
+
+          const result = await response.json();
+
+          if (!response.ok) {
+            return {
+              success: false,
+              error: result.error || 'Failed to fetch rewards',
+              message: result.message
+            };
+          }
+
+          const deposits = result.deposits || [];
+          const totals = result.totals;
+
+          const depositLines = deposits.map(d => {
+            return `  $${d.amount.toFixed(2)} | ${d.days_deposited}d | ${(d.effective_apy * 100).toFixed(2)}% APY | +$${d.unclaimed_rewards.toFixed(2)} earned`;
+          });
+
+          return {
+            success: true,
+            rewards: totals,
+            deposits: deposits,
+            formatted: `
+💰 Genesis Rewards
+
+Total Deposited: $${totals.total_deposited.toFixed(2)}
+Unclaimed Rewards: $${totals.total_rewards.toFixed(2)}
+Total Value: $${totals.total_value.toFixed(2)}
+
+Active Deposits:
+${depositLines.length > 0 ? depositLines.join('\n') : '  No active deposits'}
+
+Rewards accrue daily based on your effective APY.
+            `.trim()
+          };
+        }
+
+        case 'stats': {
+          const response = await fetch(`${apiUrl}/api/genesis/stats`);
+          const result = await response.json();
+
+          if (!response.ok) {
+            return {
+              success: false,
+              error: 'Failed to fetch stats'
+            };
+          }
+
+          const tierLines = result.multiplier_tiers?.map(t => {
+            const marker = t.status === 'current' ? '→' : t.status === 'passed' ? '✓' : ' ';
+            return `  ${marker} ${t.tvl_range.padEnd(12)} ${t.multiplier}x ${t.status}`;
+          }) || [];
+
+          return {
+            success: true,
+            stats: result,
+            formatted: `
+🌊 Genesis Liquidity Mining Stats
+
+Phase: ${result.genesis_phase} (${result.genesis_progress}% to goal)
+Total Value Locked: $${result.tvl.toFixed(2)}
+Depositors: ${result.total_depositors}
+Avg Deposit: $${result.avg_deposit.toFixed(2)}
+
+Current Multiplier: ${result.current_multiplier}x
+Base APY: ${(result.base_apy * 100).toFixed(2)}%
+
+Multiplier Tiers:
+${tierLines.join('\n')}
+
+Rewards Distributed: $${result.total_rewards_distributed.toFixed(2)}
+
+Top Depositors:
+${result.top_depositors?.slice(0, 5).map((d, i) =>
+  `  ${i + 1}. ${d.handle} - $${d.total_deposited.toFixed(2)}`
+).join('\n') || '  No depositors yet'}
+            `.trim()
+          };
+        }
+
+        default:
+          return {
+            success: false,
+            error: 'Invalid action. Use: deposit, rewards, or stats'
+          };
+      }
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Genesis action failed',
+        details: error.message
+      };
+    }
+  }
+};

package/tools/gig-browse.js

@@ -0,0 +1,206 @@
+/**
+ * vibe_gig_browse - Browse and filter the gig marketplace
+ *
+ * Search for gigs by category, skills, budget range, etc.
+ */
+
+const config = require('../config');
+const { requireInit, displayHandle, header, divider, emptyState, formatTimeAgo } = require('./_shared');
+
+const BASE_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+const definition = {
+  name: 'vibe_gig_browse',
+  description: 'Browse the gig marketplace. Filter by category, skills, budget, or search by keyword.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      category: {
+        type: 'string',
+        enum: ['build', 'fix', 'design', 'review', 'teach', 'consult', 'other'],
+        description: 'Filter by gig category'
+      },
+      skill: {
+        type: 'string',
+        description: 'Filter by required skill (e.g., "react", "python", "api")'
+      },
+      min_budget: {
+        type: 'number',
+        description: 'Minimum budget in dollars'
+      },
+      max_budget: {
+        type: 'number',
+        description: 'Maximum budget in dollars'
+      },
+      search: {
+        type: 'string',
+        description: 'Search in title and description'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number of results (default: 10, max: 50)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const {
+    category,
+    skill,
+    min_budget,
+    max_budget,
+    search,
+    limit = 10
+  } = args;
+
+  try {
+    // Build query string
+    const params = new URLSearchParams();
+    params.set('status', 'open');
+    params.set('limit', Math.min(limit, 50).toString());
+
+    // Note: API may not support all filters yet, but we include them
+    if (category) params.set('category', category);
+    if (skill) params.set('skill', skill);
+    if (min_budget) params.set('min_budget', min_budget.toString());
+    if (max_budget) params.set('max_budget', max_budget.toString());
+    if (search) params.set('search', search);
+
+    const response = await fetch(`${BASE_URL}/api/gigs?${params.toString()}`);
+    const data = await response.json();
+
+    // Handle coming soon state
+    if (data.coming_soon) {
+      return {
+        display: header('🚀 Gigs Marketplace', 2) + '\n\n' +
+          '┌────────────────────────────────────────┐\n' +
+          '│       LAUNCHING WEDNESDAY JAN 22       │\n' +
+          '└────────────────────────────────────────┘\n\n' +
+          'The gigs marketplace is almost ready!\n\n' +
+          '• Post gigs to hire builders\n' +
+          '• Apply to gigs and get paid\n' +
+          '• Build your proof-of-work reputation\n\n' +
+          'Stay tuned for the launch!'
+      };
+    }
+
+    if (!data.success) {
+      return { display: `❌ ${data.error || 'Failed to browse gigs'}` };
+    }
+
+    const gigs = data.gigs || [];
+
+    // Filter client-side if API doesn't support all filters
+    let filteredGigs = gigs;
+
+    // Client-side category filter
+    if (category) {
+      filteredGigs = filteredGigs.filter(g => g.category === category);
+    }
+
+    // Client-side skill filter (API uses skills_needed)
+    if (skill) {
+      const lowerSkill = skill.toLowerCase();
+      filteredGigs = filteredGigs.filter(g => {
+        const skills = g.skills_needed || [];
+        return skills.some(s => s.toLowerCase().includes(lowerSkill));
+      });
+    }
+
+    // Client-side budget filter (API uses budget object with min/max in dollars)
+    if (min_budget) {
+      filteredGigs = filteredGigs.filter(g => {
+        const budgetMin = g.budget?.min || 0;
+        return budgetMin >= min_budget;
+      });
+    }
+    if (max_budget) {
+      filteredGigs = filteredGigs.filter(g => {
+        const budgetMax = g.budget?.max || Infinity;
+        return budgetMax <= max_budget;
+      });
+    }
+
+    // Client-side search
+    if (search) {
+      const lowerSearch = search.toLowerCase();
+      filteredGigs = filteredGigs.filter(g =>
+        (g.title || '').toLowerCase().includes(lowerSearch) ||
+        (g.description || '').toLowerCase().includes(lowerSearch)
+      );
+    }
+
+    if (filteredGigs.length === 0) {
+      let hint = 'Try broadening your search criteria.';
+      if (category || skill) {
+        hint = `No gigs found matching your filters. Try removing some filters.`;
+      }
+      return { display: emptyState('No open gigs found', hint) };
+    }
+
+    // Build display
+    let display = header('🎯 Open Gigs', 2) + '\n\n';
+
+    // Show active filters
+    const filters = [];
+    if (category) filters.push(`category: ${category}`);
+    if (skill) filters.push(`skill: ${skill}`);
+    if (min_budget || max_budget) {
+      const budgetStr = min_budget && max_budget
+        ? `$${min_budget}-$${max_budget}`
+        : min_budget ? `≥$${min_budget}` : `≤$${max_budget}`;
+      filters.push(`budget: ${budgetStr}`);
+    }
+    if (search) filters.push(`search: "${search}"`);
+
+    if (filters.length > 0) {
+      display += `_Filters: ${filters.join(', ')}_\n\n`;
+    }
+
+    display += `Found **${filteredGigs.length}** gig${filteredGigs.length !== 1 ? 's' : ''}\n\n`;
+
+    // List gigs (API returns: poster, budget{min,max}, skills_needed, applicants as count)
+    filteredGigs.forEach((gig, i) => {
+      display += `**${i + 1}. ${gig.title}**\n`;
+      display += `   ${displayHandle(gig.poster)} • `;
+
+      // Budget is an object with min/max in dollars
+      const budgetDisplay = gig.budget
+        ? `$${gig.budget.min || 0}-$${gig.budget.max || '?'}`
+        : 'TBD';
+      display += `${budgetDisplay} • `;
+      display += `${gig.category || 'other'}\n`;
+
+      if (gig.skills_needed && gig.skills_needed.length > 0) {
+        display += `   Skills: ${gig.skills_needed.slice(0, 5).join(', ')}\n`;
+      }
+
+      if (gig.description) {
+        const shortDesc = gig.description.slice(0, 100);
+        display += `   _${shortDesc}${gig.description.length > 100 ? '...' : ''}_\n`;
+      }
+
+      // API returns applicants as a count (number), not array
+      const applicantCount = typeof gig.applicants === 'number' ? gig.applicants : 0;
+      display += `   ${applicantCount} applicant${applicantCount !== 1 ? 's' : ''} • `;
+      display += `posted ${formatTimeAgo(gig.created_at)}\n`;
+
+      display += `   **ID:** ${gig.id}\n\n`;
+    });
+
+    display += divider();
+    display += '💡 Apply to a gig with: `apply to gig [gig_id]`';
+
+    return { display };
+
+  } catch (e) {
+    console.error('[gig-browse] Error:', e);
+    return { display: `❌ Failed to browse gigs: ${e.message}` };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/gig-complete.js

@@ -0,0 +1,139 @@
+/**
+ * vibe_gig_complete - Mark a gig as completed
+ *
+ * When a gig is completed:
+ * - Links deliverables (session, artifacts, notes)
+ * - Boosts hired person's reputation
+ * - Auto-posts celebration to the board
+ * - Records rating
+ */
+
+const config = require('../config');
+const { requireInit, normalizeHandle, displayHandle, success, error, header, divider } = require('./_shared');
+
+const BASE_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+const definition = {
+  name: 'vibe_gig_complete',
+  description: 'Mark a gig as completed with deliverables and rating. Boosts reputation and posts to board.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      gig_id: {
+        type: 'string',
+        description: 'The gig ID to complete (e.g., gig_abc123)'
+      },
+      session_id: {
+        type: 'string',
+        description: 'Optional: Link a session as primary deliverable'
+      },
+      artifact_ids: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Optional: Array of artifact IDs created during the gig'
+      },
+      notes: {
+        type: 'string',
+        description: 'Optional: Completion notes or summary'
+      },
+      rating: {
+        type: 'number',
+        minimum: 1,
+        maximum: 5,
+        description: 'Rating for the hired person (1-5 stars)'
+      }
+    },
+    required: ['gig_id', 'rating']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  // Check if gigs are enabled by making a quick check
+  try {
+    const checkResponse = await fetch(`${BASE_URL}/api/gigs`);
+    const checkData = await checkResponse.json();
+    if (checkData.coming_soon) {
+      return {
+        display: header('🚀 Gigs Marketplace', 2) + '\n\n' +
+          'Launching Wednesday Jan 22!\n\n' +
+          'Gig completion will be available after launch.'
+      };
+    }
+  } catch (e) {
+    // Continue with request if check fails
+  }
+
+  const {
+    gig_id,
+    session_id = null,
+    artifact_ids = [],
+    notes = null,
+    rating
+  } = args;
+
+  const handle = config.getHandle();
+
+  // Validate rating
+  if (rating < 1 || rating > 5) {
+    return { display: error('Rating must be between 1 and 5 stars') };
+  }
+
+  try {
+    const response = await fetch(`${BASE_URL}/api/gigs/complete`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        gig_id,
+        completed_by: handle,
+        deliverables: {
+          session_id,
+          artifact_ids,
+          notes
+        },
+        rating
+      })
+    });
+
+    const data = await response.json();
+
+    if (!data.success) {
+      return { display: error(data.error || 'Failed to complete gig') };
+    }
+
+    // Format success display
+    let display = success('Gig Completed!') + '\n\n';
+
+    display += header('Gig Details', 3) + '\n';
+    display += `**Title:** ${data.gig?.title || gig_id}\n`;
+    display += `**Hired:** ${displayHandle(data.gig?.hired_handle)}\n`;
+    display += `**Rating:** ${'⭐'.repeat(rating)}\n`;
+
+    if (session_id) {
+      display += `**Session:** ${session_id}\n`;
+    }
+    if (artifact_ids.length > 0) {
+      display += `**Artifacts:** ${artifact_ids.length} linked\n`;
+    }
+    if (notes) {
+      display += `**Notes:** ${notes}\n`;
+    }
+
+    display += divider();
+    display += `${displayHandle(data.gig?.hired_handle)} earned **+50 vibe points** for completing this gig!\n`;
+
+    if (data.posted_to_board) {
+      display += `\n🎉 Celebration posted to the board`;
+    }
+
+    return { display };
+
+  } catch (e) {
+    console.error('[gig-complete] Error:', e);
+    return { display: error(`Failed to complete gig: ${e.message}`) };
+  }
+}
+
+module.exports = { definition, handler };