slashvibe-mcp 0.2.0 → 0.2.1

package/discord.js

@@ -116,6 +116,24 @@ async function postAnnouncement(message) {
   return post(null, { embed });
 }
 
+/**
+ * Post a conversation highlight
+ */
+async function postHighlight(handle, title, summary, threads = []) {
+  const threadList = threads.length > 0
+    ? '\n\n**Open threads:**\n' + threads.map(t => `• ${t}`).join('\n')
+    : '';
+
+  const embed = {
+    color: 0xF39C12, // Gold/amber for highlights
+    title: `💬 ${title}`,
+    description: summary + threadList,
+    footer: { text: `shared by @${handle} · slashvibe.dev` },
+    timestamp: new Date().toISOString()
+  };
+  return post(null, { embed });
+}
+
 /**
  * Post who's currently online
  */
@@ -147,5 +165,6 @@ module.exports = {
   postActivity,
   postStatus,
   postAnnouncement,
+  postHighlight,
   postOnlineList
 };

package/index.js

@@ -9,10 +9,44 @@
 const presence = require('./presence');
 const config = require('./config');
 const store = require('./store');
+const prompts = require('./prompts');
 
 // Tools that shouldn't show presence footer (would be redundant/noisy)
 const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update'];
 
+// Infer user prompt from tool arguments (for pattern logging)
+function inferPromptFromArgs(toolName, args) {
+  const action = toolName.replace('vibe_', '');
+  const handle = args.handle ? `@${args.handle.replace('@', '')}` : '';
+  const message = args.message ? `"${args.message.slice(0, 50)}..."` : '';
+  const note = args.note || '';
+  const mood = args.mood || '';
+  const reaction = args.reaction || '';
+
+  switch (action) {
+    case 'start': return 'start vibing';
+    case 'who': return 'who is online';
+    case 'ping': return `ping ${handle} ${note}`.trim();
+    case 'react': return `react ${reaction} to ${handle}`.trim();
+    case 'dm': return `message ${handle} ${message}`.trim();
+    case 'inbox': return 'check inbox';
+    case 'open': return `open thread with ${handle}`;
+    case 'status': return `set status to ${mood}`;
+    case 'context': return 'share context';
+    case 'summarize': return 'summarize session';
+    case 'bye': return 'end session';
+    case 'remember': return `remember about ${handle}`;
+    case 'recall': return `recall ${handle}`;
+    case 'forget': return `forget ${handle}`;
+    case 'board': return args.content ? 'post to board' : 'view board';
+    case 'invite': return 'generate invite';
+    case 'echo': return 'send feedback';
+    case 'x_mentions': return 'check x mentions';
+    case 'x_reply': return 'reply on x';
+    default: return `${action} ${handle}`.trim() || null;
+  }
+}
+
 // Generate terminal title escape sequence (OSC 0)
 function getTerminalTitle(onlineCount, unreadCount, lastActivity) {
   const parts = [];
@@ -145,7 +179,12 @@ const tools = {
   vibe_echo: require('./tools/echo'),
   // X/Twitter bridge
   vibe_x_mentions: require('./tools/x-mentions'),
-  vibe_x_reply: require('./tools/x-reply')
+  vibe_x_reply: require('./tools/x-reply'),
+  // Unified social inbox (Phase 1a)
+  vibe_social_inbox: require('./tools/social-inbox'),
+  vibe_social_post: require('./tools/social-post'),
+  // Language evolution
+  vibe_patterns: require('./tools/patterns')
 };
 
 /**
@@ -196,7 +235,19 @@ class VibeMCPServer {
         }
 
         try {
-          const result = await tool.handler(params.arguments || {});
+          // Log prompt pattern (if _prompt passed) or infer from args
+          const args = params.arguments || {};
+          const inferredPrompt = args._prompt || inferPromptFromArgs(params.name, args);
+          if (inferredPrompt) {
+            prompts.log(inferredPrompt, {
+              tool: params.name,
+              action: params.name.replace('vibe_', ''),
+              target: args.handle || args.to || null,
+              transform: args.format || args.category || null
+            });
+          }
+
+          const result = await tool.handler(args);
 
           // Add ambient presence footer (unless tool is in skip list)
           let footer = '';

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.2.0",
+  "version": "0.2.1",
+  "mcpName": "io.github.brightseth/vibe",
   "description": "Social layer for Claude Code - DMs, presence, and connection between AI-assisted developers",
   "main": "index.js",
   "bin": {

package/tools/patterns.js

@@ -0,0 +1,79 @@
+/**
+ * vibe patterns — View emerging language constructs
+ *
+ * Shows frequent prompt patterns and suggests new commands.
+ */
+
+const prompts = require('../prompts');
+
+const definition = {
+  name: 'vibe_patterns',
+  description: 'View emerging language patterns from how people use /vibe. Shows frequent prompts and suggests new commands.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      limit: {
+        type: 'number',
+        description: 'Number of recent prompts to analyze (default: 50)'
+      },
+      raw: {
+        type: 'boolean',
+        description: 'Show raw prompts instead of patterns'
+      }
+    }
+  }
+};
+
+async function handler({ limit = 50, raw = false }) {
+  if (raw) {
+    // Show raw recent prompts
+    const recent = prompts.getRecent(limit);
+
+    if (recent.length === 0) {
+      return {
+        display: `## Prompt Log\n\n_No prompts logged yet. Use /vibe and patterns will emerge._\n\nFile: \`${prompts.PROMPTS_FILE}\``
+      };
+    }
+
+    let display = `## Recent Prompts (${recent.length})\n\n`;
+    display += '| Time | Prompt | Tool |\n';
+    display += '|------|--------|------|\n';
+
+    for (const p of recent.slice(0, 20)) {
+      const time = new Date(p.ts).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+      const prompt = p.prompt.slice(0, 40) + (p.prompt.length > 40 ? '...' : '');
+      display += `| ${time} | ${prompt} | ${p.tool || '-'} |\n`;
+    }
+
+    display += `\n---\n_${recent.length} total logged · ${prompts.PROMPTS_FILE}_`;
+    return { display };
+  }
+
+  // Show patterns and suggestions
+  const patterns = prompts.extractPatterns();
+  const suggestions = prompts.suggestConstructs();
+
+  let display = '## Emerging Patterns\n\n';
+
+  if (patterns.length === 0) {
+    display += '_Not enough data yet. Keep using /vibe and patterns will emerge._\n';
+  } else {
+    display += '**Frequent patterns:**\n';
+    for (const { pattern, count } of patterns.slice(0, 10)) {
+      display += `- \`${pattern}\` (${count}x)\n`;
+    }
+  }
+
+  if (suggestions.length > 0) {
+    display += '\n**Suggested constructs:**\n';
+    for (const { pattern, construct, count } of suggestions) {
+      display += `- \`${construct}\` ← from "${pattern}" (${count}x)\n`;
+    }
+  }
+
+  display += `\n---\n_Run \`vibe patterns --raw\` to see individual prompts_`;
+
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/social-inbox.js

@@ -0,0 +1,180 @@
+/**
+ * vibe social-inbox — Unified social inbox across all channels
+ *
+ * Reads from the local cache (sync-then-read pattern) for instant access.
+ * Use --refresh to trigger a sync.
+ */
+
+const { requireInit, header, divider, formatTimeAgo } = require('./_shared');
+
+const API_URL = process.env.VIBE_API_URL || 'https://slashvibe.dev';
+
+const definition = {
+  name: 'vibe_social_inbox',
+  description: 'See messages across all connected social channels (X, Farcaster, etc.)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      channel: {
+        type: 'string',
+        enum: ['all', 'x', 'farcaster', 'discord', 'telegram', 'whatsapp', 'email'],
+        description: 'Filter by channel (default: all)'
+      },
+      high_signal: {
+        type: 'boolean',
+        description: 'Show only high-signal messages like mentions/DMs (default: true)'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number of messages to show (default: 20, max: 100)'
+      },
+      refresh: {
+        type: 'boolean',
+        description: 'Force sync from external APIs (default: false)'
+      },
+      status: {
+        type: 'boolean',
+        description: 'Show channel connection status (default: false)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const {
+    channel = 'all',
+    high_signal = true,
+    limit = 20,
+    refresh = false,
+    status = false
+  } = args;
+
+  try {
+    // Build query params
+    const params = new URLSearchParams();
+    if (channel !== 'all') params.set('channel', channel);
+    if (!high_signal) params.set('high_signal', 'false');
+    if (limit) params.set('limit', limit.toString());
+    if (refresh) params.set('refresh', 'true');
+    if (status) params.set('status', 'true');
+
+    const url = `${API_URL}/api/social?${params}`;
+
+    const response = await fetch(url);
+    const data = await response.json();
+
+    if (!data.success) {
+      return { display: `${header('Social Inbox')}\n\n_Error:_ ${data.error}` };
+    }
+
+    // Status view
+    if (status) {
+      let display = header('Channel Status');
+      display += '\n\n';
+
+      for (const [ch, info] of Object.entries(data.channels || {})) {
+        const icon = info.status?.status === 'connected' ? '✅' : '❌';
+        const configured = info.configured ? 'configured' : 'not configured';
+        display += `${icon} **${ch}** — ${configured}\n`;
+
+        if (info.status?.error) {
+          display += `   _${info.status.error}_\n`;
+        }
+
+        if (info.capabilities) {
+          const caps = [];
+          if (info.capabilities.read) caps.push('read');
+          if (info.capabilities.write) caps.push('write');
+          if (info.capabilities.dm) caps.push('dm');
+          display += `   Capabilities: ${caps.join(', ')}\n`;
+        }
+        display += '\n';
+      }
+
+      return { display };
+    }
+
+    // Inbox view
+    const messages = data.messages || [];
+
+    if (messages.length === 0) {
+      let display = header('Social Inbox');
+      display += '\n\n';
+
+      if (data.summary?.total === 0) {
+        display += '_No messages synced yet._\n\n';
+        display += 'Run `vibe social-inbox --status` to check channel connections.\n';
+        display += 'Run `vibe social-inbox --refresh` to trigger a sync.';
+      } else {
+        display += `_No ${channel === 'all' ? '' : channel + ' '}messages found._`;
+      }
+
+      return { display };
+    }
+
+    // Format messages
+    let display = header(`Social Inbox (${messages.length})`);
+    display += '\n\n';
+
+    // Group by channel for summary
+    const byChannel = {};
+    for (const msg of messages) {
+      byChannel[msg.channel] = (byChannel[msg.channel] || 0) + 1;
+    }
+
+    const channelSummary = Object.entries(byChannel)
+      .map(([ch, count]) => `${ch}: ${count}`)
+      .join(' | ');
+    display += `📬 ${channelSummary}\n`;
+    display += divider();
+    display += '\n';
+
+    // Show messages
+    for (const msg of messages) {
+      const channelIcon = getChannelIcon(msg.channel);
+      const typeIcon = getTypeIcon(msg.type);
+
+      display += `${channelIcon} **@${msg.from}** ${typeIcon} — _${msg.timeAgo}_\n`;
+      display += `${msg.content}\n`;
+      display += `_[${msg.channel}:${msg.id.split(':')[1]?.slice(0, 8)}]_\n\n`;
+    }
+
+    display += divider();
+    display += 'Reply: `vibe post "message" --x --farcaster`';
+
+    return { display };
+
+  } catch (e) {
+    return {
+      display: `${header('Social Inbox')}\n\n_Error:_ ${e.message}`
+    };
+  }
+}
+
+function getChannelIcon(channel) {
+  const icons = {
+    x: '𝕏',
+    farcaster: '🟣',
+    discord: '💬',
+    telegram: '✈️',
+    whatsapp: '💚',
+    email: '📧'
+  };
+  return icons[channel] || '📱';
+}
+
+function getTypeIcon(type) {
+  const icons = {
+    mention: '@',
+    reply: '↩️',
+    dm: '✉️',
+    like: '❤️',
+    repost: '🔁'
+  };
+  return icons[type] || '';
+}
+
+module.exports = { definition, handler };

package/tools/social-post.js

@@ -0,0 +1,141 @@
+/**
+ * vibe social-post — Post to multiple social channels at once
+ *
+ * Multi-cast posting with dry-run preview support.
+ */
+
+const { requireInit, header, divider, warning } = require('./_shared');
+
+const API_URL = process.env.VIBE_API_URL || 'https://slashvibe.dev';
+
+const definition = {
+  name: 'vibe_social_post',
+  description: 'Post content to one or more social channels (X, Farcaster, etc.)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'The content to post'
+      },
+      channels: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Channels to post to (e.g., ["x", "farcaster"])'
+      },
+      dry_run: {
+        type: 'boolean',
+        description: 'Preview post without sending (default: false)'
+      },
+      reply_to: {
+        type: 'string',
+        description: 'Message ID to reply to (e.g., "x:1234567890")'
+      }
+    },
+    required: ['content', 'channels']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { content, channels, dry_run, reply_to } = args;
+
+  // Validation
+  if (!content || typeof content !== 'string' || content.trim().length === 0) {
+    return { display: 'Need content to post.' };
+  }
+
+  if (!channels || !Array.isArray(channels) || channels.length === 0) {
+    return { display: 'Need at least one channel. Options: x, farcaster' };
+  }
+
+  const trimmed = content.trim();
+
+  // Character limit warnings
+  const warnings = [];
+  if (channels.includes('x') && trimmed.length > 280) {
+    warnings.push(`X: Content is ${trimmed.length} chars (max 280). Will be truncated.`);
+  }
+
+  try {
+    const response = await fetch(`${API_URL}/api/social`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        content: trimmed,
+        channels,
+        dry_run: dry_run || false,
+        reply_to
+      })
+    });
+
+    const data = await response.json();
+
+    if (!data.success && !data.dry_run) {
+      return { display: `${header('Post Failed')}\n\n_Error:_ ${data.error}` };
+    }
+
+    // Dry run preview
+    if (data.dry_run) {
+      let display = header('Post Preview (Dry Run)');
+      display += '\n\n';
+
+      for (const [ch, preview] of Object.entries(data.previews || {})) {
+        const icon = preview.configured ? '✅' : '❌';
+        const canPost = preview.canWrite ? 'can post' : 'read-only';
+
+        display += `${icon} **${ch}** — ${canPost}\n`;
+
+        if (!preview.configured) {
+          display += `   _Not configured_\n`;
+        } else if (preview.wouldTruncate) {
+          display += `   ⚠️ Content will be truncated to 280 chars\n`;
+        }
+
+        display += `   "${preview.content.slice(0, 100)}${preview.content.length > 100 ? '...' : ''}"\n\n`;
+      }
+
+      display += divider();
+      display += 'Remove `--dry_run` to post for real.';
+
+      return { display };
+    }
+
+    // Actual post results
+    let display = header('Posted');
+    display += '\n\n';
+
+    if (warnings.length > 0) {
+      display += warning(warnings.join('\n')) + '\n\n';
+    }
+
+    let anySuccess = false;
+    for (const [ch, result] of Object.entries(data.results || {})) {
+      if (result.success) {
+        anySuccess = true;
+        display += `✅ **${ch}** — Posted!\n`;
+        if (result.url) {
+          display += `   🔗 ${result.url}\n`;
+        }
+      } else {
+        display += `❌ **${ch}** — Failed: ${result.error}\n`;
+      }
+      display += '\n';
+    }
+
+    if (!anySuccess) {
+      display += '\n_No posts succeeded. Check channel configuration._';
+    }
+
+    return { display };
+
+  } catch (e) {
+    return {
+      display: `${header('Post Error')}\n\n_Error:_ ${e.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };