slashvibe-mcp 0.5.7 → 0.5.8

package/index.js

@@ -71,6 +71,7 @@ function inferPromptFromArgs(toolName, args) {
     case 'reservations': return 'list reservations';
     case 'solo_game': return `play ${args.game || 'game'}`;
     case 'game': return `play ${args.game || 'game'} with ${handle}`;
+    case 'poem': return args.line ? `add a line to poem with ${handle}` : `emoji poem with ${handle}`;
     case 'multiplayer_game': return `multiplayer ${args.game || 'game'}`;
     case 'drawing': return args.action ? `drawing ${args.action}` : 'collaborative drawing';
     case 'crossword': return `crossword ${args.action || 'daily'}`;
@@ -255,6 +256,10 @@ const coreTools = {
   vibe_ship: require('./tools/ship'),
   vibe_feed: require('./tools/feed'),
 
+  // Play — the original January magic: shared experiences over the DM transport
+  vibe_game: require('./tools/game'),
+  vibe_poem: require('./tools/poem'),
+
   // Matrix rooms — multiplayer
   vibe_matrix_rooms: require('./tools/matrix-rooms'),
   vibe_matrix_read: require('./tools/matrix-read'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "mcpName": "io.github.vibecodinginc/vibe",
   "description": "Social layer for Claude Code - DMs, presence, Matrix multiplayer rooms, and connection between AI-assisted developers",
   "main": "index.js",

package/store/api.js

@@ -694,15 +694,22 @@ async function getThread(myHandle, theirHandle) {
       console.error('[getThread] V2 failed, falling back to v1');
     }
 
-    // V1 fallback
+    // V1 fallback — live /api/messages returns { messages: [...] } with snake_case
+    // fields (body, created_at, source_client). Older builds returned { thread: [...] }
+    // with (text, createdAt). Accept BOTH shapes so the read path survives whichever
+    // the server sends — otherwise payload-bearing DMs (games, poems) silently vanish
+    // and every turn reads as a fresh game. This is the path the game/poem tools rely
+    // on while the v2 /threads/:id detail route is unavailable.
     const result = await request('GET', `/api/messages?user=${myHandle}&with=${theirHandle}`);
-    return (result.thread || []).map(m => ({
+    const rows = result.messages || result.thread || [];
+    return rows.map(m => ({
       from: m.from,
       isAgent: m.isAgent || m.is_agent || false, // Support both naming conventions
-      body: m.text,
+      body: m.body ?? m.text,
       payload: m.payload || null,
-      timestamp: new Date(m.createdAt).getTime(),
-      direction: m.direction
+      source_client: m.source_client || null,
+      timestamp: new Date(m.created_at || m.createdAt).getTime(),
+      direction: m.direction || (m.from === myHandle ? 'sent' : 'received'),
     }));
   } catch (e) {
     console.error('Thread failed:', e.message);

package/tools/poem.js

@@ -0,0 +1,208 @@
+/**
+ * vibe poem — Write an emoji poem together, one line at a time
+ *
+ * The original January /vibe magic: two people co-authoring something small
+ * and playful inside Claude Code, passed back and forth over the DM transport.
+ * Each turn adds a line; the poem state travels in the message payload (durable
+ * via the Postgres payload column), exactly like `vibe game`.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Poems seal automatically at this many lines (either player can seal earlier).
+const MAX_LINES = 8;
+
+/**
+ * Find the most recent poem state in a DM thread.
+ */
+function getPoemState(thread) {
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const p = thread[i].payload;
+    if (p && p.type === 'poem' && p.state) return p.state;
+  }
+  return null;
+}
+
+/**
+ * Render a poem for the terminal.
+ */
+function renderPoem(state, { withMe, them } = {}) {
+  const lines = state.lines || [];
+  let out = '📜 **emoji poem';
+  if (state.title) out += ` — ${state.title}`;
+  out += '**\n\n';
+  if (!lines.length) {
+    out += '_(blank page — add the first line)_\n';
+  } else {
+    out += '```\n';
+    for (const l of lines) out += `${l.text}\n`;
+    out += '```\n';
+    out += `\n_by ${uniqueAuthors(lines).map((a) => '@' + a).join(' & ')}_\n`;
+  }
+  return out;
+}
+
+function uniqueAuthors(lines) {
+  const seen = [];
+  for (const l of lines) if (!seen.includes(l.author)) seen.push(l.author);
+  return seen;
+}
+
+/**
+ * Whose turn is it? Alternate off the last line's author. If the last line was
+ * mine, it's their turn; if theirs (or empty), it's mine.
+ */
+function isMyTurn(state, me) {
+  const lines = state.lines || [];
+  if (!lines.length) return true; // whoever opens goes first
+  return lines[lines.length - 1].author !== me;
+}
+
+async function postPoemToBoard(state, authors) {
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+  const body = (state.lines || []).map((l) => l.text).join(' / ');
+  try {
+    await fetch(`${API_URL}/api/board`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        author: 'echo',
+        content: `${authors.map((a) => '@' + a).join(' & ')} finished an emoji poem: ${body}`,
+        category: 'general',
+      }),
+    });
+  } catch (e) {
+    console.error('[poem] Failed to post to board:', e.message);
+  }
+}
+
+const definition = {
+  name: 'vibe_poem',
+  description:
+    'Write an emoji poem together, one line at a time. Pass it back and forth with someone — each turn adds a line. `vibe poem @handle --line "🌊🌙 the tide remembers"`',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Who to write with (e.g., @solienne)',
+      },
+      line: {
+        type: 'string',
+        description: 'The line to add (emoji-forward, but any text welcome)',
+      },
+      title: {
+        type: 'string',
+        description: 'Optional title, only used when starting a new poem',
+      },
+      done: {
+        type: 'boolean',
+        description: 'Seal the poem as finished after adding your line',
+      },
+    },
+    required: ['handle'],
+  },
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { line, title, done } = args;
+  const me = config.getHandle();
+  const them = normalizeHandle(args.handle);
+
+  if (them === me) {
+    return { display: "You can't write a poem with yourself. Invite someone: `vibe poem @handle`." };
+  }
+
+  const thread = await store.getThread(me, them);
+  let state = getPoemState(thread);
+
+  // No line provided → show the current poem (or start a fresh one).
+  if (!line) {
+    if (!state) {
+      const newState = { lines: [], title: title || null, done: false, startedBy: me };
+      await store.sendMessage(
+        me,
+        them,
+        `Let's write an emoji poem together 📜 Add a line: \`vibe poem @${me} --line "…"\``,
+        'dm',
+        { type: 'poem', state: newState }
+      );
+      return {
+        display:
+          `## New emoji poem with @${them}\n\n${renderPoem(newState)}\n` +
+          `Add the first line: \`vibe poem @${them} --line "🌱 a small green start"\``,
+      };
+    }
+
+    // Show existing poem.
+    const authors = uniqueAuthors(state.lines);
+    let display = `## emoji poem with @${them}\n\n${renderPoem(state)}\n`;
+    if (state.done) {
+      display += `\n✨ Finished. Start another: \`vibe poem @${them} --line "…"\``;
+    } else if (isMyTurn(state, me)) {
+      display += `\nYour turn — add a line: \`vibe poem @${them} --line "…"\``;
+    } else {
+      display += `\nWaiting for @${them} to add the next line…`;
+    }
+    return { display };
+  }
+
+  // Adding a line.
+  if (!state) {
+    state = { lines: [], title: title || null, done: false, startedBy: me };
+  }
+
+  if (state.done) {
+    return {
+      display: `This poem is finished. Start a new one: \`vibe poem @${them} --line "…"\``,
+    };
+  }
+
+  if (!isMyTurn(state, me)) {
+    return {
+      display:
+        `It's @${them}'s turn to add a line.\n\n${renderPoem(state)}\n` +
+        `Nudge them, or wait for their line.`,
+    };
+  }
+
+  const text = String(line).trim();
+  if (!text) return { display: 'Give me a line to add: `vibe poem @handle --line "…"`' };
+  if (text.length > 200) return { display: 'Keep each line under 200 characters.' };
+
+  const newLines = [...(state.lines || []), { author: me, text }];
+  const shouldSeal = done === true || newLines.length >= MAX_LINES;
+  const newState = {
+    ...state,
+    lines: newLines,
+    done: shouldSeal,
+  };
+
+  const authors = uniqueAuthors(newLines);
+  let message;
+  if (shouldSeal) {
+    message = `Added a line and sealed our poem 📜✨\n\n${newLines.map((l) => l.text).join('\n')}`;
+    if (authors.length > 1) postPoemToBoard(newState, authors);
+  } else if (isMyTurn(newState, them)) {
+    message = `Added a line — your turn 📜\n"${text}"`;
+  } else {
+    message = `Added a line 📜\n"${text}"`;
+  }
+
+  await store.sendMessage(me, them, message, 'dm', { type: 'poem', state: newState });
+
+  let display = `## emoji poem with @${them}\n\n${renderPoem(newState)}\n`;
+  if (shouldSeal) {
+    display += `\n✨ Poem sealed${newLines.length >= MAX_LINES ? ` (${MAX_LINES} lines)` : ''}. Start another anytime.`;
+  } else {
+    display += `\nSent to @${them}. Waiting for their line…`;
+  }
+  return { display };
+}
+
+module.exports = { definition, handler };

package/version.json

@@ -1,11 +1,11 @@
 {
-  "version": "0.5.6",
-  "updated": "2026-06-30",
-  "changelog": "Come back to what you missed. Returning to /vibe now shows your unread count right away, and if we don't have an email to reach you at, we offer to arm the return-loop ping at the moment it matters — when a DM just landed while you were away.",
+  "version": "0.5.8",
+  "updated": "2026-07-03",
+  "changelog": "The January magic is back. Play a game or write a poem with another builder — right inside your terminal, turn by turn, over your DM thread. `vibe_game` for tic-tac-toe, `vibe_poem` for a collaborative emoji poem. Ship together, play together.",
   "features": [
-    "Returning 'already signed in' surface now shows your unread count instead of a static line",
-    "Contextual email nudge on return: if a DM landed while you were away and we can't reach you, we offer 'vibe email' right then",
-    "One-line, offline-only, one-click unsubscribe — the return loop only pings when you're actually gone"
+    "vibe_game — play tic-tac-toe with another viber, move by move, carried over your DM thread",
+    "vibe_poem — build a collaborative emoji poem together, one line each, until someone seals it",
+    "Fixed DM thread reads so game and poem state reliably round-trips between two people"
   ],
   "deprecated": [
     "vibe_pair — use Matrix room invites",