slashvibe-mcp 0.2.9 → 0.3.13

package/memory.js

@@ -0,0 +1,166 @@
+/**
+ * /vibe Memory — Local, thread-scoped, append-only
+ *
+ * "Messages may contain meaning. Memory requires consent."
+ *
+ * Rules:
+ * - Local-first: User can inspect ~/.vibe/memory/
+ * - Explicit consent: No ambient surveillance
+ * - Thread-scoped: Memories don't leak across contexts
+ * - Inspectable: Plain JSONL, no encryption
+ * - Append-only: Audit trail, no silent edits
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+
+const MEMORY_DIR = path.join(config.VIBE_DIR, 'memory');
+
+function ensureMemoryDir() {
+  if (!fs.existsSync(MEMORY_DIR)) {
+    fs.mkdirSync(MEMORY_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Get the thread file path for a handle
+ * Thread files are named: thread_HANDLE.jsonl
+ */
+function getThreadFile(handle) {
+  ensureMemoryDir();
+  // Sanitize handle for filename
+  const safeHandle = handle.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+  return path.join(MEMORY_DIR, `thread_${safeHandle}.jsonl`);
+}
+
+/**
+ * Append a memory to a thread
+ * Returns the memory object with timestamp
+ */
+function remember(handle, observation, metadata = {}) {
+  const threadFile = getThreadFile(handle);
+  const myHandle = config.getHandle();
+
+  const memory = {
+    id: Date.now().toString(36) + Math.random().toString(36).substring(2, 8),
+    timestamp: new Date().toISOString(),
+    observation,
+    from: myHandle,
+    about: handle,
+    ...metadata
+  };
+
+  // Append to JSONL file (one JSON object per line)
+  const line = JSON.stringify(memory) + '\n';
+  fs.appendFileSync(threadFile, line);
+
+  return memory;
+}
+
+/**
+ * Recall memories from a thread
+ * Returns array of memory objects, newest first
+ */
+function recall(handle, limit = 10) {
+  const threadFile = getThreadFile(handle);
+
+  if (!fs.existsSync(threadFile)) {
+    return [];
+  }
+
+  try {
+    const content = fs.readFileSync(threadFile, 'utf8');
+    const lines = content.trim().split('\n').filter(l => l.trim());
+    const memories = lines.map(line => {
+      try {
+        return JSON.parse(line);
+      } catch (e) {
+        return null;
+      }
+    }).filter(m => m !== null);
+
+    // Return newest first, limited
+    return memories.reverse().slice(0, limit);
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Count memories in a thread
+ */
+function count(handle) {
+  const memories = recall(handle, 10000);
+  return memories.length;
+}
+
+/**
+ * Forget all memories for a thread
+ * Returns number of memories deleted
+ */
+function forget(handle) {
+  const threadFile = getThreadFile(handle);
+
+  if (!fs.existsSync(threadFile)) {
+    return 0;
+  }
+
+  const countBefore = count(handle);
+  fs.unlinkSync(threadFile);
+  return countBefore;
+}
+
+/**
+ * List all threads with memories
+ * Returns array of { handle, count, lastUpdated }
+ */
+function listThreads() {
+  ensureMemoryDir();
+
+  try {
+    const files = fs.readdirSync(MEMORY_DIR);
+    const threads = [];
+
+    for (const file of files) {
+      if (!file.startsWith('thread_') || !file.endsWith('.jsonl')) continue;
+
+      const handle = file.replace('thread_', '').replace('.jsonl', '');
+      const filePath = path.join(MEMORY_DIR, file);
+      const stats = fs.statSync(filePath);
+      const memories = recall(handle, 10000);
+
+      threads.push({
+        handle,
+        count: memories.length,
+        lastUpdated: stats.mtime,
+        oldestMemory: memories.length > 0 ? memories[memories.length - 1].timestamp : null,
+        newestMemory: memories.length > 0 ? memories[0].timestamp : null
+      });
+    }
+
+    // Sort by last updated, newest first
+    threads.sort((a, b) => b.lastUpdated - a.lastUpdated);
+    return threads;
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Get path to memory directory (for inspection)
+ */
+function getMemoryPath() {
+  ensureMemoryDir();
+  return MEMORY_DIR;
+}
+
+module.exports = {
+  remember,
+  recall,
+  count,
+  forget,
+  listThreads,
+  getMemoryPath,
+  getThreadFile
+};

package/notification-emitter.js

@@ -0,0 +1,77 @@
+/**
+ * MCP `list_changed` notification emitter
+ *
+ * Triggers Claude to refresh tool results without reconnection.
+ * Implements debouncing to prevent notification spam.
+ *
+ * This eliminates the need for 30-second polling loops,
+ * reducing API calls by ~90% and providing instant updates.
+ */
+
+class NotificationEmitter {
+  constructor(server) {
+    this.server = server;
+    this.debounceTimers = {};
+  }
+
+  /**
+   * Emit list_changed notification with debouncing
+   * @param {string} reason - Why notification is being sent (for logging/debugging)
+   * @param {number} debounceMs - Debounce window in milliseconds (default: 1000ms)
+   */
+  emitChange(reason, debounceMs = 1000) {
+    // Debounce to prevent notification spam
+    // If we get multiple changes of the same type within the window,
+    // only emit one notification
+    if (this.debounceTimers[reason]) {
+      clearTimeout(this.debounceTimers[reason]);
+    }
+
+    this.debounceTimers[reason] = setTimeout(() => {
+      try {
+        this.server.notification({
+          method: "notifications/list_changed"
+        });
+        delete this.debounceTimers[reason];
+      } catch (e) {
+        // Silent fail - notifications are best-effort
+        // If notification fails, Claude will continue working normally
+      }
+    }, debounceMs);
+  }
+
+  /**
+   * Emit immediately without debouncing
+   * Use for urgent updates like direct mentions
+   */
+  emitImmediate() {
+    try {
+      this.server.notification({
+        method: "notifications/list_changed"
+      });
+    } catch (e) {
+      // Silent fail
+    }
+  }
+
+  /**
+   * Cancel pending notifications for a specific reason
+   * Useful when shutting down or cleaning up
+   */
+  cancel(reason) {
+    if (this.debounceTimers[reason]) {
+      clearTimeout(this.debounceTimers[reason]);
+      delete this.debounceTimers[reason];
+    }
+  }
+
+  /**
+   * Cancel all pending notifications
+   */
+  cancelAll() {
+    Object.values(this.debounceTimers).forEach(timer => clearTimeout(timer));
+    this.debounceTimers = {};
+  }
+}
+
+module.exports = NotificationEmitter;

package/notify.js

@@ -89,6 +89,8 @@ async function checkAndNotify(inbox) {
 
   let notified = false;
 
+  const myHandle = config.getHandle();
+
   for (const msg of inbox) {
     // Skip if already notified
     if (state.notifiedIds.includes(msg.id)) continue;
@@ -96,6 +98,9 @@ async function checkAndNotify(inbox) {
     // Skip if already read
     if (msg.read) continue;
 
+    // Skip messages FROM yourself (don't notify about your own sends)
+    if (myHandle && msg.from?.toLowerCase() === myHandle.toLowerCase()) continue;
+
     const msgTime = new Date(msg.createdAt).getTime();
     const age = now - msgTime;
 
@@ -104,7 +109,6 @@ async function checkAndNotify(inbox) {
     let reason = '';
 
     // Rule 1: Direct mention in message (always if not "off")
-    const myHandle = config.getHandle();
     if (myHandle && msg.text && msg.text.toLowerCase().includes(`@${myHandle}`)) {
       shouldNotify = true;
       reason = 'mention';
@@ -236,6 +240,89 @@ function checkPresence(activeUsers) {
   return justJoined;
 }
 
+/**
+ * Notify about new ships from connections (FOMO/retention driver)
+ */
+const SHIPS_STATE_FILE = path.join(config.VIBE_DIR, '.ships_state.json');
+
+function loadShipsState() {
+  try {
+    if (fs.existsSync(SHIPS_STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(SHIPS_STATE_FILE, 'utf8'));
+    }
+  } catch (e) {}
+  return { seenShipIds: [], lastCheck: null };
+}
+
+function saveShipsState(state) {
+  try {
+    fs.writeFileSync(SHIPS_STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {}
+}
+
+/**
+ * Check for new ships and notify
+ * Only notifies about ships from people in memory (connections)
+ */
+async function checkShips(memoryHandles = []) {
+  const notifyLevel = config.getNotifications();
+  if (notifyLevel === 'off') return [];
+
+  const state = loadShipsState();
+  const now = Date.now();
+  const myHandle = config.getHandle();
+  const newShips = [];
+
+  try {
+    // Fetch recent ships from board API
+    const apiUrl = config.getApiUrl();
+    const response = await fetch(`${apiUrl}/api/board?limit=10&category=shipped`);
+    const data = await response.json();
+    const ships = data.entries || [];
+
+    for (const ship of ships) {
+      // Skip if already seen
+      const shipId = ship.id || `${ship.author}-${ship.timestamp}`;
+      if (state.seenShipIds.includes(shipId)) continue;
+
+      // Skip our own ships
+      if (ship.author === myHandle) {
+        state.seenShipIds.push(shipId);
+        continue;
+      }
+
+      // Only notify about ships from connections (people in memory)
+      const isConnection = memoryHandles.includes(ship.author.toLowerCase());
+
+      if (isConnection && notifyLevel === 'all') {
+        const content = ship.content?.slice(0, 60) || 'something new';
+        showNotification(
+          `/vibe — @${ship.author} shipped! 🚀`,
+          content,
+          false,  // no system sound
+          true    // terminal bell (soft nudge)
+        );
+        newShips.push(ship);
+      }
+
+      state.seenShipIds.push(shipId);
+    }
+
+    // Trim old ship IDs (keep last 50)
+    if (state.seenShipIds.length > 50) {
+      state.seenShipIds = state.seenShipIds.slice(-50);
+    }
+
+    state.lastCheck = now;
+    saveShipsState(state);
+
+  } catch (e) {
+    // Silent fail - notifications are best-effort
+  }
+
+  return newShips;
+}
+
 /**
  * Unified notification check - call from any tool
  */
@@ -255,6 +342,19 @@ async function checkAll(store) {
     if (users.length > 0) {
       checkPresence(users);
     }
+
+    // Check for ships (only from connections)
+    // Get memory handles from local store
+    try {
+      const localStore = require('./store/local');
+      const memories = localStore.getAllThreadMemories ? localStore.getAllThreadMemories() : {};
+      const memoryHandles = Object.keys(memories).map(h => h.toLowerCase());
+      if (memoryHandles.length > 0) {
+        await checkShips(memoryHandles);
+      }
+    } catch (e) {
+      // Memory check is optional
+    }
   } catch (e) {
     // Silent fail - notifications are best-effort
   }
@@ -264,6 +364,7 @@ module.exports = {
   showNotification,
   checkAndNotify,
   checkPresence,
+  checkShips,
   checkAll,
   notify,
   ringBell

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.2.9",
-  "mcpName": "io.github.brightseth/vibe",
+  "version": "0.3.13",
+  "mcpName": "io.github.vibecodinginc/vibe",
   "description": "Social layer for Claude Code - DMs, presence, and connection between AI-assisted developers",
   "main": "index.js",
   "bin": {
-    "slashvibe-mcp": "./index.js"
+    "slashvibe-mcp": "./index.js",
+    "vibe-setup": "./setup.js"
   },
   "scripts": {
-    "start": "node index.js"
+    "start": "node index.js",
+    "test": "node --test tools/*.test.js",
+    "test:context": "node --test tools/_work-context.test.js",
+    "lint": "eslint . --ext .js",
+    "lint:fix": "eslint . --ext .js --fix"
   },
   "keywords": [
     "mcp",
@@ -23,22 +28,27 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/spirit-protocol/vibe-mcp.git"
+    "url": "git+https://github.com/VibeCodingInc/vibe-mcp.git"
   },
   "homepage": "https://slashvibe.dev",
   "bugs": {
-    "url": "https://github.com/spirit-protocol/vibe-mcp/issues"
+    "url": "https://github.com/VibeCodingInc/vibe-mcp/issues"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "files": [
     "index.js",
+    "setup.js",
+    "auth-store.js",
+    "auto-update.js",
     "config.js",
     "crypto.js",
     "discord.js",
     "memory.js",
     "notify.js",
+    "notification-emitter.js",
+    "analytics.js",
     "presence.js",
     "prompts.js",
     "twitter.js",
@@ -46,9 +56,13 @@
     "tools/",
     "store/",
     "protocol/",
+    "intelligence/",
+    "games/",
+    "bridges/",
     "README.md"
   ],
   "dependencies": {
-    "crossword-layout-generator": "^0.1.1"
+    "crossword-layout-generator": "^0.1.1",
+    "node-fetch": "^2.7.0"
   }
 }

package/prompts.js

@@ -68,7 +68,7 @@ function extractPatterns() {
 
   for (const p of prompts) {
     // Normalize: lowercase, replace @handles with @*, replace quoted strings with "*"
-    let normalized = p.prompt.toLowerCase()
+    const normalized = p.prompt.toLowerCase()
       .replace(/@\w+/g, '@*')
       .replace(/"[^"]+"/g, '"*"')
       .replace(/'[^']+'/g, "'*'")

package/protocol/index.js

@@ -101,10 +101,49 @@ const ACK_SCHEMA = {
   }
 };
 
+/**
+ * Artifact schema — For sharing artifacts in messages
+ *
+ * Example:
+ * {
+ *   type: 'artifact',
+ *   version: '0.1.0',
+ *   artifactId: 'artifact_1768035804429_1651c037',
+ *   slug: 'pizza-guide-abc123',
+ *   title: 'Stan's North Beach Pizza Guide',
+ *   template: 'guide',
+ *   preview: 'Best pizza spots in North Beach...',
+ *   url: 'https://slashvibe.dev/a/pizza-guide-abc123'
+ * }
+ */
+const ARTIFACT_SCHEMA = {
+  type: 'artifact',
+  required: ['artifactId', 'slug', 'title', 'template', 'url'],
+  validate: (payload) => {
+    if (!payload.artifactId || typeof payload.artifactId !== 'string') {
+      return { valid: false, error: 'Missing or invalid artifactId' };
+    }
+    if (!payload.slug || typeof payload.slug !== 'string') {
+      return { valid: false, error: 'Missing or invalid slug' };
+    }
+    if (!payload.title || typeof payload.title !== 'string') {
+      return { valid: false, error: 'Missing or invalid title' };
+    }
+    if (!['guide', 'learning', 'workspace'].includes(payload.template)) {
+      return { valid: false, error: 'Invalid template (must be: guide, learning, workspace)' };
+    }
+    if (!payload.url || typeof payload.url !== 'string') {
+      return { valid: false, error: 'Missing or invalid url' };
+    }
+    return { valid: true };
+  }
+};
+
 const SCHEMAS = {
   game: GAME_SCHEMA,
   handoff: HANDOFF_SCHEMA,
-  ack: ACK_SCHEMA
+  ack: ACK_SCHEMA,
+  artifact: ARTIFACT_SCHEMA
 };
 
 // ============ PROTOCOL FUNCTIONS ============
@@ -266,6 +305,10 @@ function formatPayload(payload) {
       return formatHandoffPayload(payload);
     case 'ack':
       return formatAckPayload(payload);
+    case 'artifact':
+      return formatArtifactPayload(payload);
+    case 'code':
+      return formatCodePayload(payload);
     default:
       return `📦 _${payload.type} payload_`;
   }
@@ -316,6 +359,117 @@ function formatAckPayload(payload) {
   return `${icon} Acknowledged: ${payload.replyTo} (${status})`;
 }
 
+/**
+ * Format a code snippet payload for display
+ */
+function formatCodePayload(payload) {
+  const lang = payload.language || '';
+  const filename = payload.filename || null;
+  const code = payload.code || '';
+  const description = payload.description || null;
+
+  let display = '📝 **Code Snippet**';
+  if (filename) {
+    display += ` — \`${filename}\``;
+  }
+  if (lang) {
+    display += ` (${lang})`;
+  }
+  display += '\n';
+
+  if (description) {
+    display += `> ${description}\n`;
+  }
+
+  display += `\`\`\`${lang}\n${code}\n\`\`\``;
+
+  return display;
+}
+
+/**
+ * Create a code snippet payload
+ * @param {string} code - The code content
+ * @param {object} options - Options
+ * @param {string} [options.language] - Programming language
+ * @param {string} [options.filename] - Original filename
+ * @param {string} [options.description] - Brief description
+ */
+function createCodePayload(code, options = {}) {
+  return {
+    type: 'code',
+    version: PROTOCOL_VERSION,
+    code,
+    language: options.language || detectLanguage(code),
+    filename: options.filename || null,
+    description: options.description || null,
+  };
+}
+
+/**
+ * Simple language detection based on content patterns
+ */
+function detectLanguage(code) {
+  if (!code) return '';
+
+  // Check for common patterns
+  if (code.includes('import React') || code.includes('useState') || code.includes('useEffect')) return 'jsx';
+  if (code.includes('import ') && code.includes(' from ')) return 'javascript';
+  if (code.includes('async function') || code.includes('await ')) return 'javascript';
+  if (code.includes('def ') && code.includes(':')) return 'python';
+  if (code.includes('func ') && code.includes('()')) return 'go';
+  if (code.includes('fn ') && code.includes('->')) return 'rust';
+  if (code.includes('SELECT ') || code.includes('INSERT INTO')) return 'sql';
+  if (code.includes('<!DOCTYPE') || code.includes('<html')) return 'html';
+  if (code.includes('{') && code.includes(':') && code.includes(';')) return 'css';
+  if (code.startsWith('{') && code.endsWith('}')) return 'json';
+  if (code.startsWith('#!') && code.includes('/bin/')) return 'bash';
+
+  return '';
+}
+
+function formatArtifactPayload(payload) {
+  const template = payload.template || 'artifact';
+  const templateIcon = template === 'guide' ? '📘' : template === 'learning' ? '💡' : template === 'workspace' ? '🗂️' : '📦';
+
+  let display = `${templateIcon} **${payload.title}**\n`;
+
+  if (payload.preview) {
+    const preview = payload.preview.length > 120 ? payload.preview.substring(0, 120) + '...' : payload.preview;
+    display += `> ${preview}\n\n`;
+  }
+
+  display += `🔗 [View artifact](${payload.url})`;
+
+  return display;
+}
+
+// ============ ARTIFACT HELPERS ============
+
+/**
+ * Create an artifact card payload
+ * @param {Object} artifact - Artifact object from API
+ * @returns {Object} - Artifact payload
+ */
+function createArtifactPayload(artifact) {
+  // Extract preview from first paragraph block
+  let preview = '';
+  if (artifact.content && artifact.content.blocks) {
+    const firstPara = artifact.content.blocks.find(b => b.type === 'paragraph');
+    if (firstPara && firstPara.markdown) {
+      preview = firstPara.markdown.substring(0, 150);
+    }
+  }
+
+  return createPayload('artifact', {
+    artifactId: artifact.id,
+    slug: artifact.slug,
+    title: artifact.title,
+    template: artifact.template,
+    preview: preview || undefined,
+    url: `https://slashvibe.dev/a/${artifact.slug}`
+  });
+}
+
 module.exports = {
   PROTOCOL_VERSION,
 
@@ -335,6 +489,12 @@ module.exports = {
   // Ack helpers
   createAckPayload,
 
+  // Artifact helpers
+  createArtifactPayload,
+
+  // Code helpers
+  createCodePayload,
+
   // Schemas (for extension)
   SCHEMAS
 };