slashvibe-mcp 0.5.8 → 0.5.10

package/index.js

@@ -256,9 +256,12 @@ const coreTools = {
   vibe_ship: require('./tools/ship'),
   vibe_feed: require('./tools/feed'),
 
-  // Play — the original January magic: shared experiences over the DM transport
+  // Play — the original January magic: shared experiences over the DM transport.
+  // vibe_play is the open primitive; game/poem/corpse are hardcoded on-ramps.
+  vibe_play: require('./tools/play'),
   vibe_game: require('./tools/game'),
   vibe_poem: require('./tools/poem'),
+  vibe_corpse: require('./tools/corpse'),
 
   // Matrix rooms — multiplayer
   vibe_matrix_rooms: require('./tools/matrix-rooms'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "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/tools/corpse.js

@@ -0,0 +1,269 @@
+/**
+ * vibe corpse — Write an exquisite corpse together, one line at a time
+ *
+ * The surrealist parlor game, ported to the terminal. Two people build a story
+ * (or a poem) by alternating lines — but you only ever see the LAST line the
+ * other person wrote, never the whole thing. When someone seals it, the full
+ * corpse is revealed to both, usually gloriously nonsensical.
+ *
+ * Same transport as `vibe poem` / `vibe game`: the story state travels in the
+ * DM message payload (durable via the Postgres payload column), passed back and
+ * forth over the DM thread. The only new idea here is that render hides every
+ * line but the last until the story is sealed.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Corpses seal automatically at this many lines (either player can seal earlier).
+const MAX_LINES = 10;
+
+/**
+ * Find the most recent corpse state in a DM thread.
+ */
+function getCorpseState(thread) {
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const p = thread[i].payload;
+    if (p && p.type === 'corpse' && p.state) return p.state;
+  }
+  return null;
+}
+
+function uniqueAuthors(lines) {
+  const seen = [];
+  for (const l of lines) if (!seen.includes(l.author)) seen.push(l.author);
+  return seen;
+}
+
+/**
+ * Render the full, revealed corpse (only shown once sealed).
+ */
+function renderReveal(state) {
+  const lines = state.lines || [];
+  let out = '💀 **exquisite corpse';
+  if (state.title) out += ` — ${state.title}`;
+  out += '**\n\n';
+  if (!lines.length) {
+    out += '_(empty — nothing was written)_\n';
+  } else {
+    out += '```\n';
+    for (const l of lines) out += `${l.text}\n`;
+    out += '```\n';
+    out += `\n_by ${uniqueAuthors(lines).map((a) => '@' + a).join(' & ')} — ${lines.length} lines_\n`;
+  }
+  return out;
+}
+
+/**
+ * Render the *in-progress* corpse: the whole story stays folded, you only see
+ * the last line to build from. This is the whole point of the game.
+ */
+function renderFolded(state, me) {
+  const lines = state.lines || [];
+  let out = '💀 **exquisite corpse';
+  if (state.title) out += ` — ${state.title}`;
+  out += '**\n\n';
+  if (!lines.length) {
+    out += '_(blank page — write the opening line; the rest stays hidden)_\n';
+    return out;
+  }
+  const last = lines[lines.length - 1];
+  const hiddenCount = lines.length - 1;
+  out += '```\n';
+  if (hiddenCount > 0) {
+    out += `… ${hiddenCount} line${hiddenCount === 1 ? '' : 's'} folded out of sight …\n`;
+  }
+  out += `${last.text}\n`;
+  out += '```\n';
+  out += `\n_only the last line shows — continue from it, blind to the rest_\n`;
+  return out;
+}
+
+/**
+ * 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 postCorpseToBoard(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(' & ')} unfolded an exquisite corpse: ${body}`,
+        category: 'general',
+      }),
+    });
+  } catch (e) {
+    console.error('[corpse] Failed to post to board:', e.message);
+  }
+}
+
+const definition = {
+  name: 'vibe_corpse',
+  description:
+    'Write an exquisite corpse together — a surrealist story where you only ever see the LAST line, never the whole thing, until it is sealed and revealed. Pass it back and forth: each turn adds a line, blind to what came before. `vibe corpse @handle --line "the clock swallowed its own hands"`',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Who to write with (e.g., @solienne)',
+      },
+      line: {
+        type: 'string',
+        description: 'The line to add — builds from the last visible line only',
+      },
+      title: {
+        type: 'string',
+        description: 'Optional title, only used when starting a new corpse',
+      },
+      done: {
+        type: 'boolean',
+        description: 'Seal the corpse after adding your line, revealing the whole thing to both of you',
+      },
+      reveal: {
+        type: 'boolean',
+        description: 'Show the full revealed corpse (only works once it has been sealed)',
+      },
+    },
+    required: ['handle'],
+  },
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { line, title, done, reveal } = args;
+  const me = config.getHandle();
+  const them = normalizeHandle(args.handle);
+
+  if (them === me) {
+    return { display: "You can't play exquisite corpse with yourself — half the fun is the surprise. Invite someone: `vibe corpse @handle`." };
+  }
+
+  const thread = await store.getThread(me, them);
+  let state = getCorpseState(thread);
+
+  // Explicit reveal request.
+  if (reveal) {
+    if (!state) {
+      return { display: `No corpse with @${them} yet. Start one: \`vibe corpse @${them} --line "…"\`` };
+    }
+    if (!state.done) {
+      return {
+        display:
+          `That corpse isn't sealed yet — no peeking! 💀\n\n${renderFolded(state, me)}\n` +
+          (isMyTurn(state, me)
+            ? `Your turn — add a line: \`vibe corpse @${them} --line "…"\``
+            : `Waiting for @${them} to add the next line…`),
+      };
+    }
+    return { display: `## exquisite corpse with @${them}\n\n${renderReveal(state)}` };
+  }
+
+  // No line provided → show current status (folded), or start a fresh corpse.
+  if (!line) {
+    if (!state) {
+      const newState = { lines: [], title: title || null, done: false, startedBy: me };
+      await store.sendMessage(
+        me,
+        them,
+        `Let's play exquisite corpse 💀 A surrealist story where you only see my last line. Add yours: \`vibe corpse @${me} --line "…"\``,
+        'dm',
+        { type: 'corpse', state: newState }
+      );
+      return {
+        display:
+          `## New exquisite corpse with @${them}\n\n${renderFolded(newState, me)}\n` +
+          `Write the opening line: \`vibe corpse @${them} --line "the moon filed a complaint"\``,
+      };
+    }
+
+    // Show existing corpse (folded unless sealed).
+    if (state.done) {
+      return {
+        display:
+          `## exquisite corpse with @${them}\n\n${renderReveal(state)}\n` +
+          `✨ Sealed. Start another: \`vibe corpse @${them} --line "…"\``,
+      };
+    }
+    let display = `## exquisite corpse with @${them}\n\n${renderFolded(state, me)}\n`;
+    if (isMyTurn(state, me)) {
+      display += `\nYour turn — add a line (blind to the rest): \`vibe corpse @${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 corpse is already sealed 💀\n\n${renderReveal(state)}\n` +
+        `Start a new one: \`vibe corpse @${them} --line "…"\``,
+    };
+  }
+
+  if (!isMyTurn(state, me)) {
+    return {
+      display:
+        `It's @${them}'s turn to add a line.\n\n${renderFolded(state, me)}\n` +
+        `Nudge them, or wait for their line.`,
+    };
+  }
+
+  const text = String(line).trim();
+  if (!text) return { display: 'Give me a line to add: `vibe corpse @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) {
+    // On seal, the full corpse is revealed — send it in the DM so both sides see it.
+    message =
+      `Sealed our exquisite corpse 💀✨ Here's the whole thing, unfolded:\n\n` +
+      newLines.map((l) => l.text).join('\n');
+    if (authors.length > 1) postCorpseToBoard(newState, authors);
+  } else {
+    // Mid-game: only tell them it's their turn. Do NOT echo the story — keep it folded.
+    message = `Added a line to our corpse — your turn 💀 You'll only see my last line:\n"${text}"`;
+  }
+
+  await store.sendMessage(me, them, message, 'dm', { type: 'corpse', state: newState });
+
+  if (shouldSeal) {
+    let display = `## exquisite corpse with @${them}\n\n${renderReveal(newState)}\n`;
+    display += `\n✨ Corpse sealed${newLines.length >= MAX_LINES ? ` (${MAX_LINES} lines)` : ''} and revealed to you both. Start another anytime.`;
+    return { display };
+  }
+
+  let display = `## exquisite corpse with @${them}\n\n${renderFolded(newState, me)}\n`;
+  display += `\nYour line is in. Sent to @${them}, folded away — waiting for theirs…`;
+  return { display };
+}
+
+module.exports = { definition, handler };

package/tools/play.js

@@ -0,0 +1,208 @@
+/**
+ * vibe play — the open channel for emergent, AI-improvised social play
+ *
+ * game / poem / corpse each hardcode one activity's rules. This tool hardcodes
+ * NONE. It is the bare primitive underneath all of them: carry an arbitrary
+ * `state` object back and forth over the DM thread, with a freeform `note`, and
+ * let the two Claude sessions invent whatever they want on top of it — chess,
+ * 20 questions, a co-written story, a shared drawing, a debate, a game neither
+ * player has a name for yet.
+ *
+ * The rules live in the conversation, not in this file. That's the whole point:
+ * the platform supplies the presence + the channel; the creativity is emergent
+ * from the humans and their Claudes. game/poem/corpse are now just friendly
+ * on-ramps that teach the pattern; `vibe play` is the pattern itself.
+ *
+ * Transport is identical to the others: `payload: { type:'play', ... }` on a DM,
+ * durable via the Postgres payload column, read back with store.getThread().
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Guardrail so a runaway state blob can't wedge the DM store. Generous — a
+// chess board, a long story-so-far, or a 100-cell canvas all fit easily.
+const MAX_STATE_BYTES = 24000;
+
+/**
+ * Find the most recent play session in a DM thread.
+ */
+function getPlaySession(thread) {
+  for (let i = thread.length - 1; i >= 0; i--) {
+    const p = thread[i].payload;
+    if (p && p.type === 'play') return p;
+  }
+  return null;
+}
+
+/**
+ * Accept state as a structured object/array/primitive, or a JSON string, or a
+ * plain string. We never force a shape — whatever the two Claudes agree on.
+ */
+function coerceState(raw) {
+  if (raw === undefined || raw === null) return undefined;
+  if (typeof raw === 'string') {
+    const s = raw.trim();
+    if (!s) return undefined;
+    try {
+      return JSON.parse(s);
+    } catch {
+      return s; // not JSON — keep the raw string, it's a valid state too
+    }
+  }
+  return raw;
+}
+
+function stateBytes(state) {
+  if (state === undefined) return 0;
+  try {
+    return Buffer.byteLength(typeof state === 'string' ? state : JSON.stringify(state), 'utf8');
+  } catch {
+    return Infinity;
+  }
+}
+
+/**
+ * Render whatever state is, legibly, for the local Claude to reason about.
+ */
+function renderState(state) {
+  if (state === undefined) return '_(no state yet — you define it)_';
+  if (typeof state === 'string') return '```\n' + state + '\n```';
+  try {
+    return '```json\n' + JSON.stringify(state, null, 2) + '\n```';
+  } catch {
+    return '_(unrenderable state)_';
+  }
+}
+
+const definition = {
+  name: 'vibe_play',
+  description:
+    'The open channel for playing ANY shared activity with another viber — you and their Claude improvise the rules, this tool just carries the state. No built-in game logic. Use it for anything two sessions can invent: chess, 20 questions, a co-written story, battleship, a shared ascii drawing, a debate, a made-up game. ' +
+    'Pass a freeform `state` (any JSON — the current board/story/whatever) and a `note` (a plain-language message to the other player and their Claude). ' +
+    'Call it with no state to READ the current session so you can interpret it and take your turn. This is the primitive under vibe_game / vibe_poem / vibe_corpse — reach for it when the activity is anything else.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      handle: {
+        type: 'string',
+        description: 'Who to play with (e.g., @solienne)',
+      },
+      note: {
+        type: 'string',
+        description:
+          "A plain-language message to the other player and their Claude — what you did, whose turn it is, the rules if you're starting. This is what shows in their DM.",
+      },
+      state: {
+        description:
+          'The current activity state, as any JSON value (object, array, or string). Whatever shape you and the other Claude agree on — a board, a story-so-far, a score, moves. Omit to just read the current state.',
+      },
+      kind: {
+        type: 'string',
+        description:
+          "A freeform label for the activity, e.g. 'chess', '20-questions', 'story', 'battleship'. You coin it — it's just a hint so both sides know what game this is.",
+      },
+      done: {
+        type: 'boolean',
+        description: 'Mark the activity finished after this turn.',
+      },
+    },
+    required: ['handle'],
+  },
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const me = config.getHandle();
+  const them = normalizeHandle(args.handle);
+
+  if (them === me) {
+    return { display: "You can't play with yourself here — invite someone: `vibe play @handle`." };
+  }
+
+  const thread = await store.getThread(me, them);
+  const last = getPlaySession(thread);
+
+  const incomingState = coerceState(args.state);
+  const note = args.note ? String(args.note).trim() : '';
+  const kind = (args.kind ? String(args.kind).trim() : '') || (last && last.kind) || null;
+  const done = args.done === true;
+
+  const hasWrite = incomingState !== undefined || note || done;
+
+  // ── READ: no write args → surface the current session for this Claude to act on.
+  if (!hasWrite) {
+    if (!last) {
+      return {
+        display:
+          `## play with @${them}\n\n` +
+          `_No shared activity going yet._\n\n` +
+          `Start anything — you and @${them}'s Claude make up the rules. Examples:\n` +
+          `\`vibe play @${them} --kind "chess" --note "you're white, your move" --state '{"board":"start"}'\`\n` +
+          `\`vibe play @${them} --kind "20-questions" --note "I'm thinking of something. ask away."\`\n` +
+          `\`vibe play @${them} --kind "story" --note "once upon a time..." --state "once upon a time"\`\n\n` +
+          `(For the classics there are shortcuts: \`vibe game\`, \`vibe poem\`, \`vibe corpse\`.)`,
+      };
+    }
+
+    const who = last.by === me ? 'you' : `@${last.by}`;
+    let display = `## play with @${them}${last.kind ? ` — ${last.kind}` : ''}\n\n`;
+    if (last.note) display += `last from ${who}: "${last.note}"\n\n`;
+    display += `state:\n${renderState(last.state)}\n`;
+    if (last.done) {
+      display += `\n✨ This one's finished. Start another with \`vibe play @${them} …\``;
+    } else if (last.by === me) {
+      display += `\n_Waiting on @${them} — they play next._`;
+    } else {
+      display +=
+        `\n**Your move.** Interpret the state above, decide what happens next, and send it back:\n` +
+        `\`vibe play @${them}${last.kind ? ` --kind "${last.kind}"` : ''} --note "…" --state '{…}'\`  (add \`--done\` to finish)`;
+    }
+    return { display };
+  }
+
+  // ── WRITE: take a turn.
+  // Carry the previous state forward if the caller didn't supply a new one.
+  const newState = incomingState !== undefined ? incomingState : last ? last.state : undefined;
+
+  if (stateBytes(newState) > MAX_STATE_BYTES) {
+    return {
+      display: `That state is too big (>${Math.round(MAX_STATE_BYTES / 1000)}KB). Keep the shared state compact — summarize instead of accumulating raw history.`,
+    };
+  }
+
+  const payload = {
+    type: 'play',
+    kind: kind || null,
+    state: newState,
+    note: note || null,
+    by: me,
+    done,
+  };
+
+  // The DM body is what lands in their inbox. Lead with the note; add a light
+  // hint so their Claude knows to open the session and respond.
+  let body;
+  if (done) {
+    body = note ? `${note}\n\n(sealed our ${kind || 'game'} 🎲)` : `Sealed our ${kind || 'game'} 🎲`;
+  } else {
+    body = note || `Your move 🎲`;
+    body += `\n\n▸ open with \`vibe play @${me}\` to see the state and reply`;
+  }
+
+  await store.sendMessage(me, them, body, 'dm', payload);
+
+  let display = `## play with @${them}${kind ? ` — ${kind}` : ''}\n\n`;
+  display += `state:\n${renderState(newState)}\n`;
+  if (done) {
+    display += `\n✨ Sealed and sent to @${them}. Start another anytime.`;
+  } else {
+    display += `\nSent to @${them}. Waiting for their move…`;
+  }
+  return { display };
+}
+
+module.exports = { definition, handler };

package/version.json

@@ -1,11 +1,12 @@
 {
-  "version": "0.5.8",
+  "version": "0.5.10",
   "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.",
+  "changelog": "Play anything. `vibe_play @handle` is the open channel underneath the games — it carries an arbitrary state object over your DM thread and lets you and the other person's Claude improvise the rules to whatever you invent: chess, 20 questions, a co-written story, battleship, a shared drawing, a debate. No built-in game logic — the creativity is yours. `vibe_game`, `vibe_poem`, and `vibe_corpse` are still here as quick on-ramps. Ship together, play together.",
   "features": [
-    "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"
+    "vibe_play — the open primitive: pass any JSON state + a note to another viber, read it back to take your turn, and improvise any activity two sessions can dream up",
+    "vibe_corpse — write an exquisite corpse: alternate lines blind to all but the last, then seal for the big reveal",
+    "vibe_game — play tic-tac-toe with another viber, move by move, over your DM thread",
+    "vibe_poem — build a collaborative emoji poem together, one line each"
   ],
   "deprecated": [
     "vibe_pair — use Matrix room invites",