slashvibe-mcp 0.2.2 → 0.2.4

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

@@ -34,15 +34,28 @@ function saveNotifyState(state) {
   } catch (e) {}
 }
 
+/**
+ * Ring terminal bell (BEL character)
+ * Ambient, non-intrusive alert
+ */
+function ringBell() {
+  process.stderr.write('\x07');
+}
+
 /**
  * Show a macOS notification
  */
-function showNotification(title, message, sound = false) {
+function showNotification(title, message, sound = false, bell = true) {
   if (os.platform() !== 'darwin') {
     // Only macOS supported for now
     return;
   }
 
+  // Ring terminal bell for all notifications
+  if (bell) {
+    ringBell();
+  }
+
   // Escape quotes for osascript
   const safeTitle = title.replace(/"/g, '\\"');
   const safeMessage = message.replace(/"/g, '\\"');
@@ -62,8 +75,14 @@ function showNotification(title, message, sound = false) {
 /**
  * Check for messages that need escalation
  * Called periodically or on inbox check
+ * Respects notification settings: all | mentions | off
  */
 async function checkAndNotify(inbox) {
+  const notifyLevel = config.getNotifications();
+
+  // If notifications are off, skip entirely
+  if (notifyLevel === 'off') return false;
+
   const state = loadNotifyState();
   const now = Date.now();
   const FIVE_MINUTES = 5 * 60 * 1000;
@@ -84,25 +103,25 @@ async function checkAndNotify(inbox) {
     let shouldNotify = false;
     let reason = '';
 
-    // Rule 1: Unread > 5 minutes
-    if (age > FIVE_MINUTES) {
-      shouldNotify = true;
-      reason = 'unread';
-    }
-
-    // Rule 2: Direct mention in message
+    // 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';
     }
 
-    // Rule 3: Handshake/consent request
+    // Rule 2: Handshake/consent request (always if not "off")
     if (msg.payload?.type === 'handshake') {
       shouldNotify = true;
       reason = 'handshake';
     }
 
+    // Rule 3: Unread > 5 minutes (only in "all" mode)
+    if (notifyLevel === 'all' && age > FIVE_MINUTES) {
+      shouldNotify = true;
+      reason = reason || 'unread'; // Don't override mention/handshake
+    }
+
     if (shouldNotify) {
       const preview = msg.text?.slice(0, 50) || '(no preview)';
       showNotification(
@@ -157,8 +176,11 @@ function savePresenceState(state) {
 /**
  * Check for new online users and notify
  * Returns handles that just came online
+ * Only notifies in "all" mode (presence is lower priority)
  */
 function checkPresence(activeUsers) {
+  const notifyLevel = config.getNotifications();
+
   const state = loadPresenceState();
   const now = Date.now();
   const COOLDOWN = 30 * 60 * 1000; // Don't re-notify about same person for 30 min
@@ -183,17 +205,20 @@ function checkPresence(activeUsers) {
       if (userActive) {
         justJoined.push(user);
 
-        // Show notification
-        const context = user.note || user.one_liner || 'just joined';
-        showNotification(
-          `/vibe — @${user.handle} is here`,
-          context,
-          false
-        );
+        // Only show notification in "all" mode (presence is lower priority)
+        if (notifyLevel === 'all') {
+          const context = user.note || user.one_liner || 'just joined';
+          showNotification(
+            `/vibe — @${user.handle} is here`,
+            context,
+            false,  // no system sound
+            false   // no terminal bell for presence (too noisy)
+          );
+        }
       }
     }
 
-    // Update last seen
+    // Update last seen (always track, even if not notifying)
     state.seenHandles[user.handle] = now;
   }
 
@@ -211,6 +236,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
  */
@@ -230,6 +338,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
   }
@@ -239,6 +360,8 @@ module.exports = {
   showNotification,
   checkAndNotify,
   checkPresence,
+  checkShips,
   checkAll,
-  notify
+  notify,
+  ringBell
 };

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.2.2",
-  "mcpName": "io.github.brightseth/vibe",
+  "version": "0.2.4",
+  "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"
   },
   "scripts": {
-    "start": "node index.js"
+    "start": "node index.js",
+    "test": "node --test tools/*.test.js",
+    "test:context": "node --test tools/_work-context.test.js"
   },
   "keywords": [
     "mcp",
@@ -23,11 +25,11 @@
   "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"
@@ -39,6 +41,8 @@
     "discord.js",
     "memory.js",
     "notify.js",
+    "notification-emitter.js",
+    "analytics.js",
     "presence.js",
     "prompts.js",
     "twitter.js",
@@ -46,6 +50,10 @@
     "tools/",
     "store/",
     "protocol/",
+    "intelligence/",
     "README.md"
-  ]
+  ],
+  "dependencies": {
+    "crossword-layout-generator": "^0.1.1"
+  }
 }

package/presence.js

@@ -8,6 +8,7 @@
 
 const config = require('./config');
 const store = require('./store');
+const notify = require('./notify');
 
 let heartbeatInterval = null;
 let sessionInitialized = false;
@@ -52,7 +53,7 @@ async function initSession() {
   sendHeartbeat();
 }
 
-function sendHeartbeat() {
+async function sendHeartbeat() {
   if (!config.isInitialized()) return;
 
   // Use session-aware getters (prefer session identity over shared config)
@@ -60,6 +61,9 @@ function sendHeartbeat() {
   const one_liner = config.getOneLiner();
   if (handle) {
     store.heartbeat(handle, one_liner || '');
+
+    // Check for notifications (runs in background, non-blocking)
+    notify.checkAll(store).catch(() => {});
   }
 }
 

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,8 @@ function formatPayload(payload) {
       return formatHandoffPayload(payload);
     case 'ack':
       return formatAckPayload(payload);
+    case 'artifact':
+      return formatArtifactPayload(payload);
     default:
       return `📦 _${payload.type} payload_`;
   }
@@ -316,6 +357,49 @@ function formatAckPayload(payload) {
   return `${icon} Acknowledged: ${payload.replyTo} (${status})`;
 }
 
+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 +419,9 @@ module.exports = {
   // Ack helpers
   createAckPayload,
 
+  // Artifact helpers
+  createArtifactPayload,
+
   // Schemas (for extension)
   SCHEMAS
 };