slashvibe-mcp 0.3.20 → 0.3.21

package/tools/approve.js

@@ -0,0 +1,197 @@
+/**
+ * vibe_approve — Respond to a plan with approval, rejection, or request changes
+ *
+ * Only people in the plan's requested_from list can respond.
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+const definition = {
+  name: 'vibe_approve',
+  description: 'Approve, reject, or request changes on a plan. Only invited approvers can respond.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      plan_id: {
+        type: 'string',
+        description: 'Plan ID or slug (e.g., "claude-md-cleanup" or "plan_123...")'
+      },
+      decision: {
+        type: 'string',
+        enum: ['approve', 'needs_changes', 'reject'],
+        description: 'Your decision: approve, needs_changes, or reject'
+      },
+      note: {
+        type: 'string',
+        description: 'Optional feedback or reason for your decision'
+      }
+    },
+    required: ['plan_id', 'decision']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { plan_id, decision, note } = args;
+  const myHandle = config.getHandle();
+
+  // Fetch the plan
+  const planResult = await store.getArtifact(plan_id);
+
+  if (!planResult.success || !planResult.artifact) {
+    return {
+      display: `❌ Plan not found: ${plan_id}\n\nTip: Use the plan slug (e.g., "claude-md-cleanup") or full ID.`
+    };
+  }
+
+  const plan = planResult.artifact;
+
+  // Verify it's a plan template
+  if (plan.template !== 'plan') {
+    return {
+      display: `❌ "${plan_id}" is not a plan (it's a ${plan.template})`
+    };
+  }
+
+  // Verify it has approval workflow
+  if (!plan.approval) {
+    return {
+      display: `❌ This plan doesn't have an approval workflow`
+    };
+  }
+
+  // Check if user is in the requested_from list
+  if (!plan.approval.requested_from.includes(myHandle)) {
+    return {
+      display: `❌ You're not on the approver list for this plan.\n\n**Approvers:** ${plan.approval.requested_from.map(h => `@${h}`).join(', ')}`
+    };
+  }
+
+  // Check if plan is still pending
+  if (plan.approval.status !== 'pending') {
+    return {
+      display: `⚠️ This plan is already ${plan.approval.status}.\n\nNo changes made.`
+    };
+  }
+
+  // Check if user already responded
+  const existingResponse = plan.approval.responses.find(r => r.handle === myHandle);
+  if (existingResponse) {
+    return {
+      display: `⚠️ You already responded to this plan (${existingResponse.status}).\n\nTo change your response, the plan creator would need to request again.`
+    };
+  }
+
+  // Record the response
+  const response = {
+    handle: myHandle,
+    status: decision,
+    note: note || null,
+    responded_at: new Date().toISOString()
+  };
+
+  plan.approval.responses.push(response);
+  plan.updated_at = new Date().toISOString();
+
+  // Determine new status based on decision and requires mode
+  let newStatus = 'pending';
+
+  if (decision === 'approve') {
+    if (plan.approval.requires === 'any') {
+      // Any approval is enough
+      newStatus = 'approved';
+    } else {
+      // All must approve - check if everyone has approved
+      const allApproved = plan.approval.requested_from.every(h =>
+        plan.approval.responses.some(r => r.handle === h && r.status === 'approve')
+      );
+      newStatus = allApproved ? 'approved' : 'pending';
+    }
+  } else if (decision === 'reject') {
+    // Any rejection rejects the plan
+    newStatus = 'rejected';
+  } else if (decision === 'needs_changes') {
+    // Any needs_changes puts it in that state
+    newStatus = 'needs_changes';
+  }
+
+  plan.approval.status = newStatus;
+  if (newStatus !== 'pending') {
+    plan.approval.resolved_at = new Date().toISOString();
+  }
+
+  // Save the updated plan
+  const updateResult = await store.updateArtifact(plan.id, plan);
+
+  if (!updateResult.success) {
+    return {
+      display: `❌ Failed to save response: ${updateResult.error}`
+    };
+  }
+
+  // Notify the plan creator
+  const creator = plan.created_by;
+  const statusEmoji = {
+    approve: '✅',
+    needs_changes: '🔄',
+    reject: '❌'
+  }[decision];
+
+  const statusText = {
+    approve: 'approved',
+    needs_changes: 'requested changes on',
+    reject: 'rejected'
+  }[decision];
+
+  try {
+    await store.sendMessage(myHandle, creator,
+      `${statusEmoji} **@${myHandle} ${statusText} your plan**\n\n` +
+      `**Plan:** ${plan.title}\n` +
+      (note ? `**Note:** ${note}\n` : '') +
+      `**Status:** ${newStatus === 'pending' ? '⏳ Still pending (awaiting more approvers)' : `${statusEmoji} ${newStatus.charAt(0).toUpperCase() + newStatus.slice(1)}`}`,
+      {
+        type: 'plan_response',
+        plan_id: plan.id,
+        plan_slug: plan.slug,
+        decision,
+        new_status: newStatus
+      }
+    );
+  } catch (error) {
+    console.error('[APPROVE] Failed to notify creator:', error);
+  }
+
+  // Build response
+  let display = `${statusEmoji} **Response recorded: ${decision}**\n\n`;
+  display += `**Plan:** ${plan.title}\n`;
+  display += `**Your decision:** ${decision}${note ? ` — "${note}"` : ''}\n`;
+  display += `**Plan status:** ${newStatus}\n\n`;
+
+  if (newStatus === 'approved') {
+    display += `✓ Plan is now approved! @${creator} has been notified.`;
+  } else if (newStatus === 'rejected') {
+    display += `Plan has been rejected. @${creator} has been notified.`;
+  } else if (newStatus === 'needs_changes') {
+    display += `Plan needs changes. @${creator} has been notified to update.`;
+  } else {
+    const remaining = plan.approval.requested_from.filter(h =>
+      !plan.approval.responses.some(r => r.handle === h)
+    );
+    display += `⏳ Waiting for: ${remaining.map(h => `@${h}`).join(', ')}`;
+  }
+
+  return {
+    display,
+    plan_id: plan.id,
+    plan_slug: plan.slug,
+    decision,
+    new_status: newStatus,
+    creator_notified: true
+  };
+}
+
+module.exports = { definition, handler };

package/tools/artifact-create.js

@@ -2,7 +2,7 @@
  * vibe_create_artifact - Create social artifacts from conversations
  *
  * Artifacts are first-class objects with provenance, permissions, and social context.
- * They can be guides, learnings, or workspaces - all shareable via DM.
+ * They can be guides, learnings, workspaces, or plans - all shareable via DM.
  */
 
 const config = require('../config');
@@ -11,7 +11,7 @@ const { requireInit } = require('./_shared');
 
 const definition = {
   name: 'vibe_create_artifact',
-  description: 'Create a social artifact (guide, learning, workspace) from conversation or memory. Artifacts are first-class objects with provenance and can be shared via DM.',
+  description: 'Create a social artifact (guide, learning, workspace, plan) from conversation or memory. Artifacts are first-class objects with provenance and can be shared via DM.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -25,7 +25,7 @@ const definition = {
       },
       template: {
         type: 'string',
-        enum: ['guide', 'learning', 'workspace'],
+        enum: ['guide', 'learning', 'workspace', 'plan'],
         description: 'Structural template to use'
       },
       content: {
@@ -176,6 +176,17 @@ async function handler(args) {
     forked_from: null
   };
 
+  // Add approval workflow for plan templates
+  if (template === 'plan') {
+    artifact.approval = {
+      status: 'pending',
+      requested_from: recipient ? [recipient.replace('@', '')] : [],
+      requires: 'any',  // 'any' or 'all'
+      responses: [],
+      resolved_at: null
+    };
+  }
+
   // Store artifact
   const storeResult = await store.createArtifact(artifact);
 

package/tools/artifacts-price.js

@@ -0,0 +1,107 @@
+/**
+ * vibe_artifacts_price - Set pricing for an artifact
+ *
+ * Enables artifact commerce by setting a price.
+ * Supports one-time purchase, pay-what-you-want, and tip jar models.
+ */
+
+const config = require('../config');
+const { requireInit, success, error, header } = require('./_shared');
+
+const BASE_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+const definition = {
+  name: 'vibe_artifacts_price',
+  description: 'Set pricing for an artifact you created. Enable commerce for your artifacts.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      artifact_id: {
+        type: 'string',
+        description: 'The artifact ID to price (e.g., art_abc123)'
+      },
+      price: {
+        type: 'number',
+        description: 'Price in dollars (e.g., 5.00). Set to 0 to make free.'
+      },
+      sale_type: {
+        type: 'string',
+        enum: ['one_time', 'pay_what_you_want', 'tip'],
+        description: 'Sale type: one_time (fixed price), pay_what_you_want (price is minimum), tip (free with optional tip)'
+      }
+    },
+    required: ['artifact_id', 'price', 'sale_type']
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { artifact_id, price, sale_type } = args;
+  const handle = config.getHandle();
+
+  // Validate price
+  if (price < 0) {
+    return { display: error('Price cannot be negative') };
+  }
+
+  if (price > 1000) {
+    return { display: error('Price cannot exceed $1000') };
+  }
+
+  try {
+    const response = await fetch(`${BASE_URL}/api/artifacts/price`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        artifact_id,
+        handle,
+        price_cents: Math.round(price * 100),
+        sale_type
+      })
+    });
+
+    const data = await response.json();
+
+    if (!data.success) {
+      return { display: error(data.error || 'Failed to set pricing') };
+    }
+
+    // Format display
+    let display = success('Artifact Pricing Updated') + '\n\n';
+
+    display += header('Pricing Details', 3) + '\n';
+    display += `**Artifact:** ${data.artifact?.title || artifact_id}\n`;
+    display += `**Price:** $${price.toFixed(2)}\n`;
+    display += `**Sale Type:** ${formatSaleType(sale_type)}\n`;
+    display += `**Status:** ${price > 0 ? 'For Sale' : 'Free'}\n\n`;
+
+    if (data.artifact?.url) {
+      display += `**Share Link:** ${data.artifact.url}\n`;
+    }
+
+    if (sale_type === 'pay_what_you_want') {
+      display += `\n_Buyers can pay $${price.toFixed(2)} or more_`;
+    } else if (sale_type === 'tip') {
+      display += `\n_Free to access, tips optional_`;
+    }
+
+    return { display };
+
+  } catch (e) {
+    console.error('[artifacts-price] Error:', e);
+    return { display: error(`Failed to set pricing: ${e.message}`) };
+  }
+}
+
+function formatSaleType(type) {
+  const types = {
+    one_time: 'One-Time Purchase',
+    pay_what_you_want: 'Pay What You Want',
+    tip: 'Free with Tips'
+  };
+  return types[type] || type;
+}
+
+module.exports = { definition, handler };

package/tools/available.js

@@ -0,0 +1,120 @@
+/**
+ * vibe available — Signal you're open to chat
+ *
+ * Lower the barrier to connection by explicitly signaling
+ * what topics you're happy to help with.
+ *
+ * Usage:
+ * - vibe available "React, auth, Postgres"
+ * - vibe available --clear
+ * - vibe available (show current)
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit } = require('./_shared');
+
+const definition = {
+  name: 'vibe_available',
+  description: 'Signal you\'re open to chat about specific topics. Others see you\'re available and what you can help with.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      topics: {
+        type: 'string',
+        description: 'Topics you\'re available to help with (e.g., "React, auth, Postgres")'
+      },
+      clear: {
+        type: 'boolean',
+        description: 'Clear your availability - stop signaling you\'re open'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const myHandle = config.getHandle();
+  const { topics, clear } = args;
+
+  // Clear availability
+  if (clear) {
+    await store.heartbeat(myHandle, config.getOneLiner(), {
+      availableFor: null
+    });
+
+    return {
+      display: `## Availability Cleared
+
+You're no longer signaling openness to chat.
+
+Others won't see availability topics next to your name.
+
+**To signal availability again:**
+\`vibe available "React, auth, Postgres"\``
+    };
+  }
+
+  // Show current availability
+  if (!topics) {
+    return {
+      display: `## Signal Availability
+
+Let others know you're open to chat about specific topics.
+
+**Set your availability:**
+\`vibe available "React, auth, Postgres"\`
+
+**What happens:**
+- Your presence shows: \`@${myHandle} — available for: React, auth, Postgres\`
+- Others know they won't be bothering you
+- Lower barrier to reaching out
+
+**Clear availability:**
+\`vibe available --clear\`
+
+_Availability is ephemeral — clears when you go offline._`
+    };
+  }
+
+  // Parse topics (comma or space separated)
+  const topicList = topics
+    .split(/[,\s]+/)
+    .map(t => t.trim().toLowerCase())
+    .filter(t => t.length > 0 && t.length <= 30)
+    .slice(0, 5); // Max 5 topics
+
+  if (topicList.length === 0) {
+    return {
+      display: `Please provide at least one topic. Example:\n\`vibe available "React, auth, Postgres"\``
+    };
+  }
+
+  // Update presence with availability
+  await store.heartbeat(myHandle, config.getOneLiner(), {
+    availableFor: topicList
+  });
+
+  const topicsFormatted = topicList.join(', ');
+
+  return {
+    display: `## You're Available! 🤝
+
+**Topics:** ${topicsFormatted}
+
+Others now see:
+\`@${myHandle} — available for: ${topicsFormatted}\`
+
+This signals you're open to questions about these topics.
+People are more likely to reach out when they know they won't be bothering you.
+
+**Clear when busy:**
+\`vibe available --clear\`
+
+_Availability clears automatically when you go offline._`
+  };
+}
+
+module.exports = { definition, handler };