slashvibe-mcp 0.5.14 → 0.5.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.5.14",
+  "version": "0.5.15",
   "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/weave.js

@@ -30,15 +30,16 @@ const definition = {
     'Spin the strand from what the user is ACTUALLY doing this session, inferred from their files/project/recent work — not a status they typed. ' +
     'Fields: `building` (one specific line on the current work), `stuck_on` (the wall they keep hitting, if any — an error signature or repeated symptom), `last_ship` (most recent thing that landed), `voice_sample` (2-3 sentences in the user\'s actual writing voice, so Fable can later draft replies that sound like them), `tags` (a few topic keywords). ' +
     'Everything is a distillation — never send raw source. ' +
-    'Use `action:"held"` to check whether anyone replied to a thread the user left hanging; if so it hands you the context to draft their half.',
+    'Use `action:"held"` to check whether anyone replied to a thread the user left hanging; if so it hands you the context to draft their half. ' +
+    'Use `action:"stuck"` when the user is blocked: it returns builders whose live work or shipped history may be the SAME problem already solved — you judge which candidate is truly the same problem, surface the shape of their fix, and offer a warm intro thread.',
   inputSchema: {
     type: 'object',
     properties: {
       action: {
         type: 'string',
-        enum: ['attach', 'held', 'quiet'],
+        enum: ['attach', 'held', 'stuck', 'quiet'],
         description:
-          "'attach' (default): spin/refresh your strand. 'held': surface any conversation where someone replied and you haven't answered, so you can draft the user's half. 'quiet': leave the weave (removes your strand).",
+          "'attach' (default): spin/refresh your strand. 'held': surface any conversation where someone replied and you haven't answered, so you can draft the user's half. 'stuck': find builders whose live work or shipped history is the same problem the user is blocked on (pass the wall as `stuck_on`, or it falls back to the attached strand). 'quiet': leave the weave (removes your strand).",
       },
       building: {
         type: 'string',
@@ -97,6 +98,30 @@ async function postStrand({ digest, posture }) {
   }
 }
 
+// Ask the loom for candidate SOLVERS — builders whose live work or shipped
+// history may be the same problem the user is stuck on. Actor derived server-side
+// from the token; we send only the stuck_on signature (or let the server fall
+// back to the user's own stored strand when we omit it).
+async function postSolve({ stuck_on } = {}) {
+  const token = config.getAuthToken();
+  if (!token) return { ok: false, error: 'no_token' };
+  try {
+    const resp = await fetch(`${apiBase()}/api/weave/solve`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(stuck_on ? { stuck_on } : {}),
+    });
+    const json = await resp.json().catch(() => ({}));
+    if (!resp.ok) return { ok: false, error: json.error || `http_${resp.status}` };
+    return { ok: true, data: json.data || {} };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
 /**
  * Find conversations where the other person replied and the user hasn't answered
  * yet — the "you moved on, a reply landed" signal. Uses unread count as the
@@ -198,6 +223,67 @@ async function handler(args = {}) {
     };
   }
 
+  // ── Stuck: find a solver whose work is the same problem, already solved ────
+  if (action === 'stuck') {
+    const result = await postSolve({ stuck_on: args.stuck_on || '' });
+    if (!result.ok) {
+      if (result.error === 'no_token' || result.error === 'unauthenticated') {
+        return {
+          display:
+            "⚠️ Couldn't reach the loom — your /vibe session isn't authenticated. Run `vibe init` first.",
+        };
+      }
+      return {
+        display: `⚠️ Couldn't search the weave for solvers (${result.error}). Best-effort — try again.`,
+      };
+    }
+
+    const data = result.data || {};
+    const candidates = Array.isArray(data.candidates) ? data.candidates : [];
+    if (!data.stuck_on) {
+      return {
+        display:
+          "No stuck-signal to match on. Pass what the user is fighting as `stuck_on`, " +
+          'or attach a strand with a `stuck_on` first (`vibe_weave` with the wall they keep hitting).',
+      };
+    }
+    if (candidates.length === 0) {
+      return {
+        display:
+          `Searched the weave against _"${truncate(data.stuck_on, 120)}"_ — ` +
+          `no builder's live work or shipped history looks like the same problem yet. ` +
+          `Nothing to surface; don't invent a match.`,
+      };
+    }
+
+    // Hand the raw recall pool to the model. The model IS Fable here: it decides
+    // which candidate (if any) is TRULY the same problem, describes the shape of
+    // the fix from their work, and offers a warm intro thread — never fabricates.
+    const lines = candidates.slice(0, 8).map((c) => {
+      const where = c.online ? 'live now' : 'shipped';
+      const matched = Array.isArray(c.matched) && c.matched.length
+        ? ` · overlaps: ${c.matched.slice(0, 5).join(', ')}`
+        : '';
+      return `• @${c.handle} (${where}${matched}): ${truncate(c.text || '', 200)}`;
+    });
+
+    return {
+      display:
+        `🧵 **The user is stuck on:** _"${truncate(data.stuck_on, 160)}"_\n\n` +
+        `Candidate solvers from the weave (${candidates.length} found · ${data.live || 0} live):\n` +
+        lines.join('\n') +
+        `\n\n**Your job (you are Fable at read time):** judge which candidate — if any — is ` +
+        `truly the *same problem*, not just shared keywords. Two different error messages can be ` +
+        `the same root cause; only you can see that. If one genuinely matches:\n` +
+        `  1. Name the shape of what worked for them (from their text above), so the user gets ` +
+        `unstuck even without talking.\n` +
+        `  2. Offer a warm thread: "@${'{handle}'} hit this and shipped a fix — want me to open a ` +
+        `thread so you can ask? (y)". On yes, send with \`vibe_dm @{handle}\` in the user's voice.\n` +
+        `If NONE is truly the same problem, say so plainly — never fabricate a match or a fix.`,
+      _solvers: candidates,
+    };
+  }
+
   // ── Quiet: leave the weave ────────────────────────────────────────────────
   if (action === 'quiet' || args.posture === 'quiet') {
     await postStrand({ digest: {}, posture: 'quiet' });

package/version.json

@@ -1,8 +1,9 @@
 {
-  "version": "0.5.14",
+  "version": "0.5.15",
   "updated": "2026-07-04",
-  "changelog": "New: the Weave. /vibe stops being a place you check and becomes a presence in the session you're already in. Once you sign in, your agent quietly attaches a 'strand' — a distilled read of what you're building — and when someone replies to a thread after you've moved on, Fable drafts your half of the reply in your voice and you send it with one word. You never left the terminal, and the conversation stayed warm.",
+  "changelog": "The Weave gets its most useful moment: when you're stuck, Fable finds the builder whose live work or shipped history is the SAME problem — already solved — and hands you the shape of the fix, not just an introduction. Two different error messages can be the same root cause; only Fable can see that. Ask with `vibe_weave stuck`, or let it surface when you keep circling the same wall.",
   "features": [
+    "Stuck-signatures (vibe_weave stuck) — blocked on something? Fable searches the weave for whoever already solved your exact problem — matching by the wall you're hitting, not keywords — surfaces the shape of their fix so you get unstuck, and offers to open a warm thread so you can ask. Never invents a match",
     "The Weave (vibe_weave) — attach this session's strand (what you're building, what you're stuck on, your voice) so /vibe can bring social moments INTO your terminal. Nothing to visit; the magic comes to you. Weave in full, receive-only, or quiet — opting out is first-class",
     "Fable holds your half — when someone replies to a thread you haven't answered, vibe start surfaces it and drafts your reply in your voice from what you were building. Send it with one word. Never auto-sends",
     "Received collaboration (vibe_intro) — after sign-in, your agent summarizes what you're building and /vibe matches you to a real human online whose current work or recent ship overlaps, then drafts a two-sided opener you send with one word. The signal only /vibe can see — what's inside two people's live coding sessions at once — becomes the introduction",