slashvibe-mcp 0.2.2 → 0.2.4

package/tools/insights.js

@@ -0,0 +1,123 @@
+/**
+ * vibe insights — View your behavioral patterns
+ *
+ * Shows accumulated insights about your work, social, and creative patterns.
+ * All data is stored locally (~/.vibe/work-patterns.json) and never transmitted.
+ */
+
+const patterns = require('../intelligence/patterns');
+const { requireInit, header, divider } = require('./_shared');
+
+const definition = {
+  name: 'vibe_insights',
+  description: 'View your accumulated work, social, and creative patterns.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      category: {
+        type: 'string',
+        enum: ['work', 'social', 'creative', 'all'],
+        description: 'Which patterns to show (default: all)'
+      }
+    }
+  }
+};
+
+function formatTimeAgo(timestamp) {
+  if (!timestamp) return 'unknown';
+  const seconds = Math.floor((Date.now() - timestamp) / 1000);
+  if (seconds < 60) return 'just now';
+  if (seconds < 3600) return Math.floor(seconds / 60) + 'm ago';
+  if (seconds < 86400) return Math.floor(seconds / 3600) + 'h ago';
+  return Math.floor(seconds / 86400) + 'd ago';
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const category = args.category || 'all';
+  let display = header('Your Patterns');
+  display += '\n_Local only_\n\n';
+
+  const data = patterns.load();
+
+  if (!patterns.hasEnoughData()) {
+    display += '_Not enough data yet — keep vibing!_\n';
+    display += '_Sessions: ' + data.sessions.total + '_';
+    return { display };
+  }
+
+  // Work patterns
+  if (category === 'all' || category === 'work') {
+    const rhythm = patterns.getSessionRhythm();
+    const peakHours = patterns.getPeakHours();
+    const dominantState = patterns.getDominantState();
+    const topModules = patterns.getTopModules(3);
+
+    display += '**Work**\n';
+    display += rhythm.totalSessions + ' sessions · ' + rhythm.totalHours + 'h total\n';
+    display += 'avg ' + rhythm.averageMinutes + 'm · longest ' + rhythm.longestMinutes + 'm\n';
+
+    if (peakHours.length > 0) {
+      const hours = peakHours.map(h => h.hour + ':00').join(', ');
+      display += 'peak: ' + hours + '\n';
+    }
+
+    if (dominantState) {
+      display += 'usually: ' + dominantState.state + ' (' + dominantState.percentage + '%)\n';
+    }
+
+    if (topModules.length > 0) {
+      const mods = topModules.map(m => m.name).join(', ');
+      display += 'focus: ' + mods + '\n';
+    }
+
+    display += '\n';
+  }
+
+  // Social patterns
+  if (category === 'all' || category === 'social') {
+    const social = patterns.getSocialSummary();
+    const topConnections = patterns.getTopConnections(3);
+
+    display += '**Social**\n';
+    display += social.messagesSent + ' sent · ' + social.messagesReceived + ' received\n';
+    display += social.uniqueConnections + ' connections\n';
+
+    if (topConnections.length > 0) {
+      const names = topConnections.map(c => '@' + c.handle).join(', ');
+      display += 'closest: ' + names + '\n';
+    }
+
+    display += '\n';
+  }
+
+  // Creative patterns
+  if (category === 'all' || category === 'creative') {
+    const creative = patterns.getCreativeSummary();
+    const topDomains = patterns.getTopDomains(3);
+    const inspirations = patterns.getInspirations(3);
+
+    display += '**Creative**\n';
+    display += creative.totalShips + ' ships · ' + creative.totalIdeas + ' ideas · ' + creative.totalRiffs + ' riffs\n';
+
+    if (topDomains.length > 0) {
+      const domains = topDomains.map(d => '#' + d.domain).join(' ');
+      display += 'domains: ' + domains + '\n';
+    }
+
+    if (inspirations.length > 0) {
+      const names = inspirations.map(i => '@' + i.handle).join(', ');
+      display += 'inspired by: ' + names + '\n';
+    }
+
+    display += '\n';
+  }
+
+  display += divider() + '_since ' + formatTimeAgo(new Date(data.firstSeen).getTime()) + '_';
+
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/invite.js

@@ -1,10 +1,14 @@
 /**
- * vibe invite — Generate a shareable invite
+ * vibe invite — Generate invite codes and shareable messages
  *
- * Creates a personalized invite message for sharing with friends.
+ * Actions:
+ * - generate: Create a new invite code
+ * - list: See your existing codes
+ * - (default): Generate a shareable message with your code
  */
 
 const config = require('../config');
+const store = require('../store');
 const { requireInit } = require('./_shared');
 
 const definition = {
@@ -13,6 +17,10 @@ const definition = {
   inputSchema: {
     type: 'object',
     properties: {
+      action: {
+        type: 'string',
+        description: 'Action: "generate" to create code, "list" to see your codes, or omit for shareable message'
+      },
       name: {
         type: 'string',
         description: 'Optional: Friend\'s name for personalized message'
@@ -36,15 +44,118 @@ async function handler(args) {
   const initCheck = requireInit();
   if (initCheck) return initCheck;
 
-  const { name, format } = args;
+  const { action, name, format } = args;
   const myHandle = config.getHandle();
 
-  const url = 'slashvibe.dev';
+  // Generate a new invite code
+  if (action === 'generate') {
+    const result = await store.generateInviteCode(myHandle);
+
+    if (!result.success) {
+      return {
+        display: `## Could not generate invite code
+
+${result.error || result.message || 'Unknown error'}
+
+${result.remaining === 0 ? 'Share your existing codes first, or wait for them to be used.' : ''}`
+      };
+    }
+
+    return {
+      display: `## New Invite Code Generated
+
+**${result.code}**
+
+Share link: ${result.share_url}
+
+Expires: ${result.expires_at}
+Remaining codes: ${result.remaining}
+
+_When your friend redeems this code, you'll earn a bonus code._`
+    };
+  }
+
+  // List existing codes
+  if (action === 'list') {
+    const result = await store.getMyInvites(myHandle);
+
+    if (!result.success) {
+      return {
+        display: `## Could not fetch invites
+
+${result.error || 'Unknown error'}`
+      };
+    }
+
+    if (!result.codes || result.codes.length === 0) {
+      return {
+        display: `## Your Invite Codes
+
+No codes yet. Run \`vibe invite --action generate\` to create one.
+
+You can have up to ${result.max_codes} unused codes at a time.`
+      };
+    }
+
+    const available = result.codes.filter(c => c.status === 'available');
+    const used = result.codes.filter(c => c.status === 'used');
+
+    let display = `## Your Invite Codes
+
+**Available** (${available.length}/${result.max_codes})
+`;
+
+    if (available.length > 0) {
+      for (const code of available) {
+        display += `\n- **${code.code}** — ${code.share_url}`;
+      }
+    } else {
+      display += '\n_No available codes. Generate one or wait for existing codes to be used._';
+    }
+
+    if (used.length > 0) {
+      display += `\n\n**Used** (${used.length})`;
+      for (const code of used) {
+        display += `\n- ${code.code} → @${code.used_by} (${code.used_at?.split('T')[0] || 'unknown'})`;
+      }
+    }
+
+    if (result.can_generate) {
+      display += '\n\n_Run `vibe invite --action generate` to create a new code._';
+    }
+
+    return { display };
+  }
+
+  // Get an available code, or auto-generate one
+  let shareCode = null;
+  let justGenerated = false;
+
+  const codesResult = await store.getMyInvites(myHandle);
+  if (codesResult.success && codesResult.codes) {
+    const available = codesResult.codes.find(c => c.status === 'available');
+    if (available) {
+      shareCode = available.code;
+    }
+  }
+
+  // Auto-generate if no available code and user can generate
+  if (!shareCode && codesResult.success && codesResult.can_generate) {
+    const genResult = await store.generateInviteCode(myHandle);
+    if (genResult.success) {
+      shareCode = genResult.code;
+      justGenerated = true;
+    }
+  }
+
+  const shareUrl = shareCode
+    ? `slashvibe.dev/invite/${shareCode}`
+    : 'slashvibe.dev';
 
   // Just the link
   if (format === 'link') {
     return {
-      display: `**${url}**
+      display: `**${shareUrl}**
 
 Copy and share this with anyone using Claude Code.`
     };
@@ -58,38 +169,48 @@ Copy and share this with anyone using Claude Code.`
 
 > ${randomMsg}
 >
-> ${url}
+> ${shareUrl}
 
 _Copy the above and send it._`
     };
   }
 
-  // Full personalized message (default)
-  const greeting = name ? `Hey ${name}!` : 'Hey!';
-  const fromLine = myHandle ? ` — @${myHandle}` : '';
-
-  return {
-    display: `## Invite to /vibe
+  // Default: Quick copy-ready format
+  // If name provided, make it personalized
+  if (name) {
+    return {
+      display: `## Invite for ${name}
 
 ---
 
-${greeting}
+Hey ${name}!
 
-I've been using this thing called /vibe in Claude Code — it's a social layer that lets you see who else is building and message people without leaving your terminal.
+I've been using /vibe in Claude Code — it's a social layer that lets you see who else is building and message people without leaving your terminal.
 
-No app to install really, you just tell Claude:
+Just tell Claude: "go to slashvibe.dev and install /vibe"
 
-  "go to slashvibe.dev and install /vibe"
+Then say "let's vibe" to start. I'm @${myHandle} — ping me once you're on!
 
-Then say "let's vibe" to start.
+---
 
-${name ? `Hit me up once you're on — I'm @${myHandle}` : `I'm @${myHandle} if you want to ping me.`}${fromLine}
+**${shareUrl}**
 
----
+_Copy the link above and send it._`
+    };
+  }
+
+  // No name: ultra-short copy-ready format
+  const genNote = justGenerated ? ' (just generated)' : '';
+  const randomMsg = INVITE_MESSAGES[Math.floor(Math.random() * INVITE_MESSAGES.length)];
+
+  return {
+    display: `## Quick Invite${genNote}
 
-**Shareable link**: ${url}
+> ${randomMsg}
+>
+> **${shareUrl}**
 
-_Copy and send to a friend who uses Claude Code._`
+_Copy and send. ${shareCode ? `Bonus code earned when they join.` : ''}_`
   };
 }
 

package/tools/l2-bridge.js

@@ -0,0 +1,272 @@
+/**
+ * vibe_bridge - Bridge ETH between Base and VIBE L2
+ *
+ * Move assets to VIBE L2 to mint artifacts and interact with
+ * the Shipback economy.
+ *
+ * Deposit: Base → VIBE L2 (~1 minute)
+ * Withdrawal: VIBE L2 → Base (~7 days, or ~1 hour with fast mode)
+ *
+ * Examples:
+ * - "vibe bridge deposit 0.1"    - Move 0.1 ETH to VIBE L2
+ * - "vibe bridge status"         - Check bridge status
+ * - "vibe bridge withdraw 0.05"  - Move ETH back to Base
+ */
+
+const fetch = require('node-fetch');
+const config = require('../config');
+
+const definition = {
+  name: 'vibe_bridge',
+  description: 'Bridge ETH between Base and VIBE L2. Deposit to mint artifacts, withdraw to cash out.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Action: deposit, withdraw, status, estimate (default: status)'
+      },
+      amount: {
+        type: 'string',
+        description: 'Amount in ETH (e.g., "0.1")'
+      },
+      tx_hash: {
+        type: 'string',
+        description: 'Transaction hash to check status'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const { action = 'status', amount, tx_hash } = args;
+
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  const handle = config.getHandle();
+
+  try {
+    switch (action) {
+      case 'status':
+        return await getBridgeStatus(handle, tx_hash);
+
+      case 'deposit':
+        return await initiateDeposit(handle, amount);
+
+      case 'withdraw':
+        return await initiateWithdraw(handle, amount);
+
+      case 'estimate':
+        return await estimateGas(amount);
+
+      default:
+        return {
+          display: `Unknown action: ${action}\n\nValid actions: deposit, withdraw, status, estimate`
+        };
+    }
+  } catch (error) {
+    return {
+      display: `❌ Bridge operation failed: ${error.message}`
+    };
+  }
+}
+
+/**
+ * Get bridge status
+ */
+async function getBridgeStatus(handle, txHash) {
+  const formatted = `
+┌────────────────────────────────────────────────────────────┐
+│                    🌉 VIBE BRIDGE                          │
+│               Base ←→ VIBE L2                              │
+├────────────────────────────────────────────────────────────┤
+│                                                            │
+│  Deposit (Base → VIBE L2)                                  │
+│  ├─ Time: ~1 minute                                        │
+│  ├─ Supported: ETH, USDC                                   │
+│  └─ Use: Mint artifacts, interact with contracts           │
+│                                                            │
+│  Withdrawal (VIBE L2 → Base)                               │
+│  ├─ Standard: ~7 days (challenge period)                   │
+│  ├─ Fast: ~1 hour (OP Succinct, coming soon)              │
+│  └─ Supported: ETH, USDC                                   │
+│                                                            │
+├────────────────────────────────────────────────────────────┤
+│  Commands:                                                 │
+│  ├─ vibe bridge deposit 0.1  - Deposit 0.1 ETH            │
+│  ├─ vibe bridge withdraw 0.1 - Withdraw 0.1 ETH           │
+│  ├─ vibe bridge estimate     - Estimate gas costs         │
+│  └─ vibe bridge status       - This screen                │
+│                                                            │
+├────────────────────────────────────────────────────────────┤
+│  Bridge UI: https://bridge.vibe.network                    │
+│  Explorer:  https://explorer.vibe.network                  │
+└────────────────────────────────────────────────────────────┘
+`.trim();
+
+  if (txHash) {
+    return {
+      display: formatted + `\n\n📍 Check your transaction: https://explorer.vibe.network/tx/${txHash}`,
+      explorerUrl: `https://explorer.vibe.network/tx/${txHash}`
+    };
+  }
+
+  return {
+    display: formatted,
+    bridgeInfo: {
+      depositTime: '~1 minute',
+      withdrawTime: '~7 days (standard) / ~1 hour (fast)',
+      supportedAssets: ['ETH', 'USDC'],
+      bridgeUrl: 'https://bridge.vibe.network',
+      explorerUrl: 'https://explorer.vibe.network'
+    }
+  };
+}
+
+/**
+ * Initiate deposit (Base → VIBE L2)
+ */
+async function initiateDeposit(handle, amount) {
+  if (!amount) {
+    return {
+      display: 'Amount required. Example: vibe bridge deposit 0.1'
+    };
+  }
+
+  const amountFloat = parseFloat(amount);
+  if (isNaN(amountFloat) || amountFloat <= 0) {
+    return {
+      display: 'Invalid amount. Must be a positive number.'
+    };
+  }
+
+  return {
+    display: `🌉 DEPOSIT ${amount} ETH to VIBE L2
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Amount: ${amount} ETH
+From: Base
+To: VIBE L2
+Time: ~1 minute
+
+To complete this deposit:
+
+Option 1: Bridge UI (Recommended)
+  Visit https://bridge.vibe.network
+  Connect your wallet
+  Select "Deposit" and enter ${amount} ETH
+
+Option 2: Direct Contract Call
+  Contract: StandardBridge on Base
+  Function: depositETH
+  Gas Limit: ~100,000
+
+Note: After depositing, your ETH will be available on
+VIBE L2 within ~1 minute. You can then mint artifacts
+and earn Shipback!`,
+    action: 'deposit_guidance',
+    amount,
+    bridgeUrl: `https://bridge.vibe.network?amount=${amount}&direction=deposit`
+  };
+}
+
+/**
+ * Initiate withdrawal (VIBE L2 → Base)
+ */
+async function initiateWithdraw(handle, amount) {
+  if (!amount) {
+    return {
+      display: 'Amount required. Example: vibe bridge withdraw 0.1'
+    };
+  }
+
+  const amountFloat = parseFloat(amount);
+  if (isNaN(amountFloat) || amountFloat <= 0) {
+    return {
+      display: 'Invalid amount. Must be a positive number.'
+    };
+  }
+
+  return {
+    display: `🌉 WITHDRAW ${amount} ETH to Base
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Amount: ${amount} ETH
+From: VIBE L2
+To: Base
+Time: ~7 days (standard) or ~1 hour (fast mode)
+
+⚠️ IMPORTANT: Withdrawals have a 7-day challenge period.
+This is standard for OP Stack chains (same as Base, Optimism).
+
+Fast withdrawals (~1 hour) will be available with OP Succinct.
+
+To complete this withdrawal:
+
+1. Visit https://bridge.vibe.network
+2. Connect your wallet
+3. Select "Withdraw" and enter ${amount} ETH
+4. Submit the transaction on VIBE L2
+5. Wait for challenge period
+6. Finalize on Base
+
+Alternative: Claim your Shipback earnings instead!
+  → vibe shipback balance`,
+    action: 'withdraw_guidance',
+    amount,
+    standardTime: '7 days',
+    fastTime: '~1 hour (coming soon)',
+    bridgeUrl: `https://bridge.vibe.network?amount=${amount}&direction=withdraw`
+  };
+}
+
+/**
+ * Estimate gas costs
+ */
+async function estimateGas(amount) {
+  const depositGas = 100000;
+  const withdrawGas = 150000;
+  const gasPrice = 0.001; // gwei on L2
+  const baseGasPrice = 0.5; // gwei on Base
+
+  const depositCostEth = (depositGas * baseGasPrice) / 1e9;
+  const withdrawCostL2 = (withdrawGas * gasPrice) / 1e9;
+  const withdrawCostBase = (depositGas * baseGasPrice) / 1e9;
+
+  return {
+    display: `⛽ BRIDGE GAS ESTIMATES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Deposit (Base → VIBE L2):
+  Gas: ~${depositGas.toLocaleString()} units
+  Cost: ~${depositCostEth.toFixed(6)} ETH
+  Note: Paid on Base
+
+Withdrawal (VIBE L2 → Base):
+  Initiate (on L2): ~${withdrawCostL2.toFixed(8)} ETH
+  Finalize (on Base): ~${withdrawCostBase.toFixed(6)} ETH
+  Total: ~${(withdrawCostL2 + withdrawCostBase).toFixed(6)} ETH
+
+On VIBE L2:
+  Gas price: ~${gasPrice} gwei (ultra cheap!)
+  Mint cost: ~0.0001 ETH
+
+💡 Tip: VIBE L2 has very low gas fees.
+   Deposit once, mint many artifacts cheaply!`,
+    estimates: {
+      deposit: { gas: depositGas, costEth: depositCostEth },
+      withdraw: {
+        initiateGas: withdrawGas,
+        finalizeCostEth: withdrawCostBase,
+        totalCostEth: withdrawCostL2 + withdrawCostBase
+      },
+      l2GasPrice: gasPrice
+    }
+  };
+}
+
+module.exports = { definition, handler };