slashvibe-mcp 0.3.21 → 0.3.22

package/tools/{l2-status.js → _experimental/l2-status.js}

@@ -15,17 +15,17 @@ const fetch = require('node-fetch');
 // Chain configuration (matches lib/vibe-l2/config.js)
 const CHAINS = {
   'vibe-l2': {
-    chainId: 84532000,  // Mainnet
+    chainId: 84532000, // Mainnet
     name: 'VIBE L2',
     rpcUrl: process.env.VIBE_L2_RPC || 'https://rpc.vibe.network',
-    explorerUrl: 'https://explorer.vibe.network',
+    explorerUrl: 'https://explorer.vibe.network'
   },
   'vibe-l2-testnet': {
-    chainId: 84532001,  // Testnet
+    chainId: 84532001, // Testnet
     name: 'VIBE L2 Testnet',
     rpcUrl: process.env.VIBE_L2_TESTNET_RPC || 'https://rpc-testnet.vibe.network',
-    explorerUrl: 'https://explorer-testnet.vibe.network',
-  },
+    explorerUrl: 'https://explorer-testnet.vibe.network'
+  }
 };
 
 const definition = {
@@ -48,60 +48,60 @@ const definition = {
 
 async function handler(args) {
   const { network = 'vibe-l2-testnet', verbose = false } = args;
-    try {
-      const chain = CHAINS[network];
-      if (!chain) {
-        return {
-          success: false,
-          error: `Unknown network: ${network}`,
-          available: Object.keys(CHAINS)
-        };
-      }
+  try {
+    const chain = CHAINS[network];
+    if (!chain) {
+      return {
+        success: false,
+        error: `Unknown network: ${network}`,
+        available: Object.keys(CHAINS)
+      };
+    }
 
-      // Check RPC health
-      const rpcStatus = await checkRpcHealth(chain.rpcUrl);
+    // Check RPC health
+    const rpcStatus = await checkRpcHealth(chain.rpcUrl);
 
-      // Get contract addresses from environment
-      // Standardized format: VIBE_ARTIFACTS_TESTNET or VIBE_ARTIFACTS_MAINNET
-      const envSuffix = network === 'vibe-l2' ? 'MAINNET' : 'TESTNET';
-      const contracts = {
-        vibeArtifacts: process.env[`VIBE_ARTIFACTS_${envSuffix}`],
-        shipbackRegistry: process.env[`SHIPBACK_REGISTRY_${envSuffix}`],
-        vibeToken: process.env[`VIBE_TOKEN_${envSuffix}`],
-      };
+    // Get contract addresses from environment
+    // Standardized format: VIBE_ARTIFACTS_TESTNET or VIBE_ARTIFACTS_MAINNET
+    const envSuffix = network === 'vibe-l2' ? 'MAINNET' : 'TESTNET';
+    const contracts = {
+      vibeArtifacts: process.env[`VIBE_ARTIFACTS_${envSuffix}`],
+      shipbackRegistry: process.env[`SHIPBACK_REGISTRY_${envSuffix}`],
+      vibeToken: process.env[`VIBE_TOKEN_${envSuffix}`]
+    };
 
-      // Check Shipback API health
-      const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
-      let apiHealth = { status: 'unknown' };
-      try {
-        const apiResp = await fetch(`${apiUrl}/api/health?full=true`, { timeout: 5000 });
-        apiHealth = await apiResp.json();
-      } catch (e) {
-        apiHealth = { status: 'error', error: e.message };
-      }
+    // Check Shipback API health
+    const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+    let apiHealth = { status: 'unknown' };
+    try {
+      const apiResp = await fetch(`${apiUrl}/api/health?full=true`, { timeout: 5000 });
+      apiHealth = await apiResp.json();
+    } catch (e) {
+      apiHealth = { status: 'error', error: e.message };
+    }
 
-      // Build status report
-      const status = {
-        network: chain.name,
-        chainId: chain.chainId,
-        rpc: {
-          url: chain.rpcUrl,
-          ...rpcStatus
-        },
-        contracts: {
-          vibeArtifacts: contracts.vibeArtifacts || 'not deployed',
-          shipbackRegistry: contracts.shipbackRegistry || 'not deployed',
-          vibeToken: contracts.vibeToken || 'not deployed (optional)',
-        },
-        api: apiHealth.status === 'healthy' ? 'healthy' : apiHealth.status,
-        explorer: chain.explorerUrl
-      };
+    // Build status report
+    const status = {
+      network: chain.name,
+      chainId: chain.chainId,
+      rpc: {
+        url: chain.rpcUrl,
+        ...rpcStatus
+      },
+      contracts: {
+        vibeArtifacts: contracts.vibeArtifacts || 'not deployed',
+        shipbackRegistry: contracts.shipbackRegistry || 'not deployed',
+        vibeToken: contracts.vibeToken || 'not deployed (optional)'
+      },
+      api: apiHealth.status === 'healthy' ? 'healthy' : apiHealth.status,
+      explorer: chain.explorerUrl
+    };
 
-      // Format output
-      const rpcIcon = rpcStatus.healthy ? '🟢' : '🔴';
-      const apiIcon = apiHealth.status === 'healthy' ? '🟢' : '🟡';
+    // Format output
+    const rpcIcon = rpcStatus.healthy ? '🟢' : '🔴';
+    const apiIcon = apiHealth.status === 'healthy' ? '🟢' : '🟡';
 
-      let formatted = `
+    let formatted = `
 ┌─────────────────────────────────────────────────────┐
 │              VIBE L2 STATUS                         │
 ├─────────────────────────────────────────────────────┤
@@ -121,28 +121,27 @@ async function handler(args) {
 └─────────────────────────────────────────────────────┘
 `.trim();
 
-      if (verbose && rpcStatus.healthy) {
-        formatted += `\n\nDetailed RPC Info:
+    if (verbose && rpcStatus.healthy) {
+      formatted += `\n\nDetailed RPC Info:
   Latest Block: ${rpcStatus.blockNumber}
   Block Time: ${rpcStatus.blockTime || 'unknown'}
   Gas Price: ${rpcStatus.gasPrice} gwei
   Chain ID: ${rpcStatus.chainId}`;
-      }
-
-      // Shipback info
-      formatted += `\n\n💰 Shipback Distribution: 80% creator / 15% protocol / 5% foundation`;
-      formatted += `\n📖 Explorer: ${chain.explorerUrl}`;
+    }
 
-      return {
-        display: formatted,
-        data: status
-      };
+    // Shipback info
+    formatted += `\n\n💰 Shipback Distribution: 80% creator / 15% protocol / 5% foundation`;
+    formatted += `\n📖 Explorer: ${chain.explorerUrl}`;
 
-    } catch (error) {
-      return {
-        display: `❌ Failed to check L2 status: ${error.message}`
-      };
-    }
+    return {
+      display: formatted,
+      data: status
+    };
+  } catch (error) {
+    return {
+      display: `❌ Failed to check L2 status: ${error.message}`
+    };
+  }
 }
 
 /**
@@ -205,7 +204,6 @@ async function checkRpcHealth(rpcUrl) {
       chainId,
       latency: 'ok'
     };
-
   } catch (error) {
     return {
       healthy: false,

package/tools/{shipback.js → _experimental/shipback.js}

@@ -253,9 +253,10 @@ async function initiateClaim(apiUrl, handle, signature, nonce) {
   const balanceData = await balanceResp.json();
 
   if (!balanceData.canClaim) {
-    const reason = parseFloat(balanceData.pendingBalanceEth) < parseFloat(balanceData.minClaimAmountEth)
-      ? `Balance (${balanceData.pendingBalanceEth} ETH) below minimum (${balanceData.minClaimAmountEth} ETH)`
-      : `Cooldown active until ${balanceData.cooldownEndsAt}`;
+    const reason =
+      parseFloat(balanceData.pendingBalanceEth) < parseFloat(balanceData.minClaimAmountEth)
+        ? `Balance (${balanceData.pendingBalanceEth} ETH) below minimum (${balanceData.minClaimAmountEth} ETH)`
+        : `Cooldown active until ${balanceData.cooldownEndsAt}`;
 
     return {
       display: `❌ Cannot claim yet: ${reason}

package/tools/_proactive-discovery.js

@@ -1,6 +1,6 @@
 /**
  * Proactive Discovery Engine — Smart background matching for offline users
- * 
+ *
  * This runs when users aren't online to:
  * - Analyze recent ships and suggest collaborations
  * - Pre-compute high-quality matches for when users return
@@ -16,19 +16,19 @@ const { formatTimeAgo } = require('./_shared');
 async function analyzeShippingPatterns() {
   const profiles = await userProfiles.getAllProfiles();
   const now = Date.now();
-  const twoWeeksAgo = now - (14 * 24 * 60 * 60 * 1000);
-  
+  const twoWeeksAgo = now - 14 * 24 * 60 * 60 * 1000;
+
   const patterns = {
     recentShippers: [],
     complementaryShips: [],
     similarProjects: [],
     emergingTrends: {}
   };
-  
+
   // Find users who shipped recently
   for (const profile of profiles) {
     if (!profile.ships || profile.ships.length === 0) continue;
-    
+
     const recentShips = profile.ships.filter(s => s.timestamp > twoWeeksAgo);
     if (recentShips.length > 0) {
       patterns.recentShippers.push({
@@ -40,7 +40,7 @@ async function analyzeShippingPatterns() {
       });
     }
   }
-  
+
   // Find complementary ships (e.g., one shipped frontend, another backend)
   const complementaryPairs = [
     { keywords: ['frontend', 'ui', 'react', 'vue'], complement: ['backend', 'api', 'server', 'database'] },
@@ -49,24 +49,16 @@ async function analyzeShippingPatterns() {
     { keywords: ['mobile', 'app', 'ios', 'android'], complement: ['backend', 'api'] },
     { keywords: ['smart contract', 'solidity', 'web3'], complement: ['frontend', 'dapp'] }
   ];
-  
+
   for (const pair of complementaryPairs) {
-    const primaryShippers = patterns.recentShippers.filter(s => 
-      s.ships.some(ship => 
-        pair.keywords.some(keyword => 
-          ship.what.toLowerCase().includes(keyword)
-        )
-      )
+    const primaryShippers = patterns.recentShippers.filter(s =>
+      s.ships.some(ship => pair.keywords.some(keyword => ship.what.toLowerCase().includes(keyword)))
     );
-    
-    const complementShippers = patterns.recentShippers.filter(s => 
-      s.ships.some(ship => 
-        pair.complement.some(keyword => 
-          ship.what.toLowerCase().includes(keyword)
-        )
-      )
+
+    const complementShippers = patterns.recentShippers.filter(s =>
+      s.ships.some(ship => pair.complement.some(keyword => ship.what.toLowerCase().includes(keyword)))
     );
-    
+
     if (primaryShippers.length > 0 && complementShippers.length > 0) {
       patterns.complementaryShips.push({
         type: `${pair.keywords[0]}/${pair.complement[0]}`,
@@ -75,15 +67,17 @@ async function analyzeShippingPatterns() {
       });
     }
   }
-  
+
   // Find similar project patterns
   const projectKeywords = {};
   for (const shipper of patterns.recentShippers) {
     for (const ship of shipper.ships) {
-      const words = ship.what.toLowerCase().split(/\s+/)
+      const words = ship.what
+        .toLowerCase()
+        .split(/\s+/)
         .filter(word => word.length > 3)
         .filter(word => !['the', 'and', 'for', 'with', 'that', 'this'].includes(word));
-      
+
       for (const word of words) {
         if (!projectKeywords[word]) projectKeywords[word] = [];
         projectKeywords[word].push({
@@ -94,7 +88,7 @@ async function analyzeShippingPatterns() {
       }
     }
   }
-  
+
   // Find keywords with multiple recent ships (emerging trends)
   for (const [keyword, ships] of Object.entries(projectKeywords)) {
     if (ships.length >= 2 && keyword !== 'app' && keyword !== 'website') {
@@ -104,7 +98,7 @@ async function analyzeShippingPatterns() {
       };
     }
   }
-  
+
   return patterns;
 }
 
@@ -112,36 +106,31 @@ async function analyzeShippingPatterns() {
 async function preComputeMatches() {
   const profiles = await userProfiles.getAllProfiles();
   const now = Date.now();
-  const oneWeekAgo = now - (7 * 24 * 60 * 60 * 1000);
-  
+  const oneWeekAgo = now - 7 * 24 * 60 * 60 * 1000;
+
   // Find users who haven't been active but have good profiles
-  const dormantUsers = profiles.filter(p => 
-    p.lastSeen && p.lastSeen < oneWeekAgo &&
-    p.building && p.interests?.length > 0
-  );
-  
-  const activeUsers = profiles.filter(p => 
-    p.lastSeen && p.lastSeen > oneWeekAgo
+  const dormantUsers = profiles.filter(
+    p => p.lastSeen && p.lastSeen < oneWeekAgo && p.building && p.interests?.length > 0
   );
-  
+
+  const activeUsers = profiles.filter(p => p.lastSeen && p.lastSeen > oneWeekAgo);
+
   const preComputedMatches = [];
-  
+
   for (const dormantUser of dormantUsers) {
     const potentialMatches = [];
-    
+
     for (const activeUser of activeUsers) {
       if (dormantUser.handle === activeUser.handle) continue;
-      
+
       // Check if already connected
-      const alreadyConnected = await userProfiles.hasBeenConnected(
-        dormantUser.handle, 
-        activeUser.handle
-      );
+      const alreadyConnected = await userProfiles.hasBeenConnected(dormantUser.handle, activeUser.handle);
       if (alreadyConnected) continue;
-      
+
       // Calculate match score using existing algorithm
       const match = calculateSimpleMatchScore(dormantUser, activeUser);
-      if (match.score > 15) { // Higher threshold for dormant users
+      if (match.score > 15) {
+        // Higher threshold for dormant users
         potentialMatches.push({
           handle: activeUser.handle,
           score: match.score,
@@ -150,7 +139,7 @@ async function preComputeMatches() {
         });
       }
     }
-    
+
     if (potentialMatches.length > 0) {
       preComputedMatches.push({
         dormantUser: dormantUser.handle,
@@ -159,7 +148,7 @@ async function preComputeMatches() {
       });
     }
   }
-  
+
   return preComputedMatches;
 }
 
@@ -167,7 +156,7 @@ async function preComputeMatches() {
 function calculateSimpleMatchScore(user1, user2) {
   let score = 0;
   const reasons = [];
-  
+
   // Interest overlap
   if (user1.interests && user2.interests) {
     const shared = user1.interests.filter(i => user2.interests.includes(i));
@@ -176,8 +165,8 @@ function calculateSimpleMatchScore(user1, user2) {
       reasons.push(`Shared interests: ${shared.slice(0, 2).join(', ')}`);
     }
   }
-  
-  // Tag overlap  
+
+  // Tag overlap
   if (user1.tags && user2.tags) {
     const sharedTags = user1.tags.filter(t => user2.tags.includes(t));
     if (sharedTags.length > 0) {
@@ -185,7 +174,7 @@ function calculateSimpleMatchScore(user1, user2) {
       reasons.push(`Similar skills: ${sharedTags.slice(0, 2).join(', ')}`);
     }
   }
-  
+
   // Building similarity
   if (user1.building && user2.building) {
     const building1 = user1.building.toLowerCase();
@@ -198,7 +187,7 @@ function calculateSimpleMatchScore(user1, user2) {
       reasons.push(`Both working on ${overlap[0]}`);
     }
   }
-  
+
   return { score, reasons: reasons.slice(0, 2) };
 }
 
@@ -206,21 +195,21 @@ function calculateSimpleMatchScore(user1, user2) {
 async function identifyEmergingClusters() {
   const profiles = await userProfiles.getAllProfiles();
   const now = Date.now();
-  const oneMonthAgo = now - (30 * 24 * 60 * 60 * 1000);
-  
+  const oneMonthAgo = now - 30 * 24 * 60 * 60 * 1000;
+
   // Only consider recent users for emerging trends
   const recentProfiles = profiles.filter(p => p.firstSeen && p.firstSeen > oneMonthAgo);
-  
+
   if (recentProfiles.length < 3) {
     return { message: 'Not enough recent users to identify emerging clusters' };
   }
-  
+
   const clusters = {};
-  
+
   // Group by interests
   for (const profile of recentProfiles) {
     if (!profile.interests || profile.interests.length === 0) continue;
-    
+
     for (const interest of profile.interests) {
       if (!clusters[interest]) {
         clusters[interest] = [];
@@ -228,7 +217,7 @@ async function identifyEmergingClusters() {
       clusters[interest].push(profile.handle);
     }
   }
-  
+
   // Find clusters with 2+ recent users (potential communities)
   const emergingClusters = Object.entries(clusters)
     .filter(([interest, handles]) => handles.length >= 2)
@@ -239,7 +228,7 @@ async function identifyEmergingClusters() {
       potential: handles.length >= 3 ? 'high' : 'medium'
     }))
     .sort((a, b) => b.size - a.size);
-  
+
   return emergingClusters;
 }
 
@@ -247,17 +236,17 @@ async function identifyEmergingClusters() {
 async function suggestOptimalTiming() {
   const profiles = await userProfiles.getAllProfiles();
   const now = Date.now();
-  
+
   // Analyze when users are typically active
   const activityPatterns = {};
-  
+
   for (const profile of profiles) {
     if (!profile.lastSeen) continue;
-    
+
     const lastSeenDate = new Date(profile.lastSeen);
     const hour = lastSeenDate.getHours();
     const dayOfWeek = lastSeenDate.getDay();
-    
+
     if (!activityPatterns[profile.handle]) {
       activityPatterns[profile.handle] = {
         preferredHours: [],
@@ -265,11 +254,11 @@ async function suggestOptimalTiming() {
         timezone: null // Could be inferred from activity patterns
       };
     }
-    
+
     activityPatterns[profile.handle].preferredHours.push(hour);
     activityPatterns[profile.handle].preferredDays.push(dayOfWeek);
   }
-  
+
   // Find common active hours across users
   const hourCounts = {};
   for (const pattern of Object.values(activityPatterns)) {
@@ -277,18 +266,16 @@ async function suggestOptimalTiming() {
       hourCounts[hour] = (hourCounts[hour] || 0) + 1;
     }
   }
-  
+
   const peakHours = Object.entries(hourCounts)
-    .sort(([,a], [,b]) => b - a)
+    .sort(([, a], [, b]) => b - a)
     .slice(0, 3)
     .map(([hour, count]) => ({ hour: parseInt(hour), userCount: count }));
-  
+
   return {
     peakActivityHours: peakHours,
     totalActiveUsers: Object.keys(activityPatterns).length,
-    recommendedConnectionTimes: peakHours.map(p => 
-      `${p.hour}:00 (${p.userCount} users typically active)`
-    )
+    recommendedConnectionTimes: peakHours.map(p => `${p.hour}:00 (${p.userCount} users typically active)`)
   };
 }
 
@@ -298,4 +285,4 @@ module.exports = {
   identifyEmergingClusters,
   suggestOptimalTiming,
   calculateSimpleMatchScore
-};
+};

package/tools/_shared/index.js

@@ -7,70 +7,34 @@
  * - Time formatting
  * - Display formatting
  * - Error handling
- * - Relevancy API fetching
  */
 
-const config = require('../../config');
-
-// ============ RELEVANCY API ============
-
-const RELEVANCY_API_TIMEOUT = 5000; // 5 seconds
-
 /**
- * Fetch relevant users from the Universal Relevancy API
- *
- * @param {string} handle - The requesting user's handle
- * @param {string} context - The context: 'discovery', 'dm_suggest', 'feed', 'notification'
- * @param {number} limit - Max results (default 5)
- * @returns {Promise<{ matches: object[], tier: string, fromApi: boolean } | null>}
+ * @typedef {Object} ToolResult
+ * @property {string} [display] - Formatted text to show the user
+ * @property {string} [hint] - Hint for Claude about next action
+ * @property {Object} [suggestion] - Suggested next action
+ * @property {number} [unread_count] - Unread message count
+ * @property {string} [for_handle] - Handle this result is relevant to
  */
-async function fetchRelevantUsers(handle, context = 'discovery', limit = 5) {
-  try {
-    const apiUrl = config.getApiUrl();
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), RELEVANCY_API_TIMEOUT);
-
-    const url = `${apiUrl}/api/relevancy?handle=${encodeURIComponent(handle)}&context=${context}&limit=${limit}`;
-
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: {
-        'Accept': 'application/json',
-        'User-Agent': 'vibe-mcp-client'
-      },
-      signal: controller.signal
-    });
-
-    clearTimeout(timeout);
-
-    if (!response.ok) {
-      console.log(`[relevancy] API returned ${response.status}`);
-      return null;
-    }
 
-    const data = await response.json();
+/**
+ * @typedef {Object} ToolDefinition
+ * @property {string} name - Tool name (vibe_*)
+ * @property {string} description - Human-readable description
+ * @property {Object} inputSchema - JSON Schema for tool arguments
+ * @property {string} inputSchema.type - Always "object"
+ * @property {Object} inputSchema.properties - Argument definitions
+ * @property {string[]} [inputSchema.required] - Required argument names
+ */
 
-    if (!data.success || !data.matches) {
-      console.log('[relevancy] API returned unsuccessful response');
-      return null;
-    }
+/**
+ * @typedef {Object} ToolModule
+ * @property {ToolDefinition} definition - Tool schema definition
+ * @property {function(Object): Promise<ToolResult>} handler - Tool handler function
+ */
 
-    return {
-      matches: data.matches,
-      tier: data.tier,
-      socialStats: data.socialStats,
-      fromApi: true
-    };
-  } catch (e) {
-    // Log but don't fail - caller should handle null gracefully
-    if (e.name === 'AbortError') {
-      console.log('[relevancy] API timeout');
-    } else {
-      console.log('[relevancy] API error:', e.message);
-    }
-    return null;
-  }
-}
+const config = require('../../config');
 
 // ============ INIT CHECK ============
 
@@ -93,7 +57,7 @@ function requireInit() {
  * @returns {Function} - Wrapped handler
  */
 function withInit(handler) {
-  return async function(args) {
+  return async function (args) {
     const initCheck = requireInit();
     if (initCheck) return initCheck;
     return handler(args);
@@ -245,7 +209,7 @@ function error(message) {
  * @returns {Function} - Wrapped handler with try/catch
  */
 function withErrorHandling(handler) {
-  return async function(args) {
+  return async function (args) {
     try {
       return await handler(args);
     } catch (e) {
@@ -262,7 +226,7 @@ function withErrorHandling(handler) {
  * @returns {Function} - Combined wrapper
  */
 function compose(...wrappers) {
-  return function(handler) {
+  return function (handler) {
     return wrappers.reduceRight((h, wrapper) => wrapper(h), handler);
   };
 }
@@ -291,10 +255,20 @@ function validateRequired(args, required) {
   return null;
 }
 
-module.exports = {
-  // Relevancy
-  fetchRelevantUsers,
+// ============ DEBUG ============
+
+/**
+ * Debug logging — only outputs when VIBE_DEBUG=true
+ * @param {string} tag - Log tag (e.g., 'DM', 'GAME')
+ * @param {...any} args - Values to log
+ */
+function debug(tag, ...args) {
+  if (process.env.VIBE_DEBUG === 'true') {
+    console.error(`[vibe:${tag}]`, ...args);
+  }
+}
 
+module.exports = {
   // Init
   requireInit,
   withInit,
@@ -322,5 +296,8 @@ module.exports = {
   withDefaults,
 
   // Validation
-  validateRequired
+  validateRequired,
+
+  // Debug
+  debug
 };