slashvibe-mcp 0.2.2 → 0.2.4

package/store/reservations.js

@@ -0,0 +1,321 @@
+/**
+ * Reservations Store — Local-first file reservations
+ *
+ * Advisory locks to signal edit intent and reduce conflicts.
+ * Stored locally in ~/.vibe/reservations/
+ *
+ * Key behaviors:
+ * - Scope auto-detected from git remote, fallback to cwd
+ * - Paths are relative to scope
+ * - TTL is client-enforced (check expires_ts on read)
+ * - Warn on conflict (overlapping exclusive paths), don't block
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const crypto = require('crypto');
+
+const RESERVATIONS_DIR = path.join(process.env.HOME, '.vibe', 'reservations');
+const ACTIVE_FILE = path.join(RESERVATIONS_DIR, 'active.jsonl');
+const HISTORY_FILE = path.join(RESERVATIONS_DIR, 'history.jsonl');
+const INDEX_FILE = path.join(RESERVATIONS_DIR, 'index.json');
+
+// Ensure directories exist
+function ensureDir() {
+  if (!fs.existsSync(RESERVATIONS_DIR)) {
+    fs.mkdirSync(RESERVATIONS_DIR, { recursive: true });
+  }
+}
+
+// Generate reservation ID: rsv-{nanoid}
+function generateId() {
+  return 'rsv-' + crypto.randomBytes(4).toString('hex');
+}
+
+// Get git remote URL for scope
+function getGitRemote() {
+  try {
+    const remote = execSync('git remote get-url origin 2>/dev/null', { encoding: 'utf8' }).trim();
+    // Normalize: git@github.com:user/repo.git → github.com/user/repo
+    if (remote.startsWith('git@')) {
+      return remote.replace('git@', '').replace(':', '/').replace('.git', '');
+    }
+    // https://github.com/user/repo.git → github.com/user/repo
+    if (remote.startsWith('https://')) {
+      return remote.replace('https://', '').replace('.git', '');
+    }
+    return remote;
+  } catch (e) {
+    return null;
+  }
+}
+
+// Get current working directory name as fallback scope
+function getLocalScope() {
+  try {
+    const root = execSync('git rev-parse --show-toplevel 2>/dev/null', { encoding: 'utf8' }).trim();
+    return `local:${path.basename(root)}`;
+  } catch (e) {
+    return `local:${path.basename(process.cwd())}`;
+  }
+}
+
+// Get scope for reservations
+function getScope() {
+  const remote = getGitRemote();
+  if (remote) {
+    return `repo:${remote}`;
+  }
+  return getLocalScope();
+}
+
+// Read all active reservations
+function readActive() {
+  ensureDir();
+  if (!fs.existsSync(ACTIVE_FILE)) {
+    return [];
+  }
+  const content = fs.readFileSync(ACTIVE_FILE, 'utf8');
+  const reservations = content
+    .split('\n')
+    .filter(line => line.trim())
+    .map(line => {
+      try {
+        return JSON.parse(line);
+      } catch (e) {
+        return null;
+      }
+    })
+    .filter(r => r !== null);
+
+  // Filter out expired
+  const now = new Date().toISOString();
+  return reservations.filter(r => r.expires_ts > now && r.status === 'active');
+}
+
+// Write active reservations (rewrite entire file)
+function writeActive(reservations) {
+  ensureDir();
+  const content = reservations.map(r => JSON.stringify(r)).join('\n') + (reservations.length ? '\n' : '');
+  fs.writeFileSync(ACTIVE_FILE, content);
+}
+
+// Append to history
+function appendHistory(reservation) {
+  ensureDir();
+  fs.appendFileSync(HISTORY_FILE, JSON.stringify(reservation) + '\n');
+}
+
+// Update index (for quick lookups)
+function updateIndex(reservations) {
+  ensureDir();
+  const index = {
+    count: reservations.length,
+    byPath: {},
+    byId: {},
+    updatedAt: new Date().toISOString()
+  };
+
+  for (const r of reservations) {
+    index.byId[r.reservation_id] = r;
+    for (const p of r.paths) {
+      if (!index.byPath[p]) {
+        index.byPath[p] = [];
+      }
+      index.byPath[p].push(r.reservation_id);
+    }
+  }
+
+  fs.writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2));
+}
+
+// Check for conflicts with existing reservations
+function checkConflicts(paths, exclusive = true, scope = null) {
+  const active = readActive();
+  const targetScope = scope || getScope();
+  const conflicts = [];
+
+  for (const reservation of active) {
+    // Only check same scope
+    if (reservation.scope !== targetScope) continue;
+    // Only check exclusive reservations
+    if (!reservation.exclusive) continue;
+
+    // Check path overlap
+    for (const newPath of paths) {
+      for (const existingPath of reservation.paths) {
+        // Exact match
+        if (newPath === existingPath) {
+          conflicts.push({
+            path: newPath,
+            reservation_id: reservation.reservation_id,
+            owner: reservation.owner,
+            reason: reservation.reason,
+            expires_ts: reservation.expires_ts
+          });
+        }
+        // Check if new path is under existing (existing: src/, new: src/auth.ts)
+        else if (newPath.startsWith(existingPath + '/')) {
+          conflicts.push({
+            path: newPath,
+            conflictsWith: existingPath,
+            reservation_id: reservation.reservation_id,
+            owner: reservation.owner,
+            reason: reservation.reason,
+            expires_ts: reservation.expires_ts
+          });
+        }
+        // Check if existing path is under new (existing: src/auth.ts, new: src/)
+        else if (existingPath.startsWith(newPath + '/')) {
+          conflicts.push({
+            path: existingPath,
+            conflictsWith: newPath,
+            reservation_id: reservation.reservation_id,
+            owner: reservation.owner,
+            reason: reservation.reason,
+            expires_ts: reservation.expires_ts
+          });
+        }
+      }
+    }
+  }
+
+  return conflicts;
+}
+
+// Create a new reservation
+function create(owner, paths, options = {}) {
+  const {
+    ttl_seconds = 3600,
+    exclusive = true,
+    reason = null,
+    thread_id = null
+  } = options;
+
+  const scope = getScope();
+  const now = new Date();
+  const expires = new Date(now.getTime() + ttl_seconds * 1000);
+
+  // Check for conflicts
+  const conflicts = checkConflicts(paths, exclusive, scope);
+
+  const reservation = {
+    reservation_id: generateId(),
+    scope,
+    paths,
+    exclusive,
+    reason,
+    thread_id,
+    owner,
+    status: 'active',
+    ttl_seconds,
+    issued_ts: now.toISOString(),
+    expires_ts: expires.toISOString()
+  };
+
+  // Add to active
+  const active = readActive();
+  active.push(reservation);
+  writeActive(active);
+  updateIndex(active);
+
+  return {
+    reservation,
+    conflicts: conflicts.length > 0 ? conflicts : null,
+    warning: conflicts.length > 0 ? `${conflicts.length} conflicting reservation(s) found` : null
+  };
+}
+
+// Release a reservation
+function release(reservation_id, owner = null) {
+  const active = readActive();
+  const index = active.findIndex(r => r.reservation_id === reservation_id);
+
+  if (index === -1) {
+    return { success: false, error: 'not_found', message: 'Reservation not found or already expired' };
+  }
+
+  const reservation = active[index];
+
+  // Optional owner check
+  if (owner && reservation.owner !== owner) {
+    return { success: false, error: 'not_owner', message: 'You are not the owner of this reservation' };
+  }
+
+  // Mark as released and move to history
+  reservation.status = 'released';
+  reservation.released_ts = new Date().toISOString();
+  appendHistory(reservation);
+
+  // Remove from active
+  active.splice(index, 1);
+  writeActive(active);
+  updateIndex(active);
+
+  return { success: true, reservation };
+}
+
+// List reservations
+function list(options = {}) {
+  const { active_only = true, path_filter = null, scope_filter = null } = options;
+
+  let reservations = readActive();
+
+  // Filter by scope
+  if (scope_filter) {
+    reservations = reservations.filter(r => r.scope === scope_filter);
+  } else {
+    // Default: only show current scope
+    const currentScope = getScope();
+    reservations = reservations.filter(r => r.scope === currentScope);
+  }
+
+  // Filter by path
+  if (path_filter) {
+    reservations = reservations.filter(r =>
+      r.paths.some(p => p.includes(path_filter) || path_filter.includes(p))
+    );
+  }
+
+  return reservations;
+}
+
+// Get a single reservation by ID
+function get(reservation_id) {
+  const active = readActive();
+  return active.find(r => r.reservation_id === reservation_id) || null;
+}
+
+// Cleanup expired reservations (called periodically)
+function cleanup() {
+  const active = readActive();
+  const now = new Date().toISOString();
+  const expired = active.filter(r => r.expires_ts <= now);
+  const remaining = active.filter(r => r.expires_ts > now);
+
+  // Move expired to history
+  for (const r of expired) {
+    r.status = 'expired';
+    r.expired_ts = now;
+    appendHistory(r);
+  }
+
+  if (expired.length > 0) {
+    writeActive(remaining);
+    updateIndex(remaining);
+  }
+
+  return { expired: expired.length, remaining: remaining.length };
+}
+
+module.exports = {
+  create,
+  release,
+  list,
+  get,
+  getScope,
+  checkConflicts,
+  cleanup,
+  generateId
+};

package/store/skills.js

@@ -0,0 +1,378 @@
+/**
+ * Skills Exchange Store — Marketplace for skills trading
+ *
+ * Manages skill offers and requests:
+ * - Users can offer skills they have (with expertise level)
+ * - Users can request skills they need (with urgency/project context)
+ * - Smart matching between skill offers and requests
+ * - Track successful exchanges and feedback
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('../config');
+const userProfiles = require('./profiles');
+
+const SKILLS_FILE = path.join(config.VIBE_DIR, 'skills.json');
+
+// Core skills categories for structured matching
+const SKILL_CATEGORIES = {
+  'Engineering': ['frontend', 'backend', 'fullstack', 'mobile', 'devops', 'ai/ml', 'data', 'security'],
+  'Design': ['ui/ux', 'visual', 'branding', 'illustration', 'animation', 'research'],
+  'Business': ['marketing', 'sales', 'strategy', 'finance', 'operations', 'legal'],
+  'Content': ['writing', 'copywriting', 'video', 'photography', 'podcast', 'social'],
+  'Product': ['pm', 'growth', 'analytics', 'user-research', 'strategy'],
+  'Other': ['consulting', 'mentoring', 'networking', 'feedback']
+};
+
+// Load skills data from disk
+function loadSkillsData() {
+  try {
+    if (fs.existsSync(SKILLS_FILE)) {
+      const data = fs.readFileSync(SKILLS_FILE, 'utf8');
+      return JSON.parse(data);
+    }
+  } catch (e) {
+    console.warn('Failed to load skills data:', e.message);
+  }
+  return { offers: [], requests: [], exchanges: [] };
+}
+
+// Save skills data to disk
+function saveSkillsData(data) {
+  try {
+    fs.writeFileSync(SKILLS_FILE, JSON.stringify(data, null, 2));
+  } catch (e) {
+    console.error('Failed to save skills data:', e.message);
+  }
+}
+
+// Add a skill offer
+async function addSkillOffer(handle, skill, details = {}) {
+  const data = loadSkillsData();
+  const offer = {
+    id: Date.now().toString(),
+    handle: handle.toLowerCase().replace('@', ''),
+    skill: skill.toLowerCase(),
+    category: getCategoryForSkill(skill),
+    level: details.level || 'intermediate', // beginner, intermediate, expert
+    availability: details.availability || 'flexible', // flexible, limited, busy
+    format: details.format || ['chat', 'call'], // chat, call, pair, review
+    description: details.description || null,
+    examples: details.examples || [], // Links to work examples
+    timestamp: Date.now(),
+    status: 'active' // active, paused, fulfilled
+  };
+  
+  // Remove duplicate offers for same skill
+  data.offers = data.offers.filter(o => !(o.handle === offer.handle && o.skill === offer.skill));
+  data.offers.unshift(offer);
+  
+  saveSkillsData(data);
+  return offer;
+}
+
+// Add a skill request
+async function addSkillRequest(handle, skill, details = {}) {
+  const data = loadSkillsData();
+  const request = {
+    id: Date.now().toString(),
+    handle: handle.toLowerCase().replace('@', ''),
+    skill: skill.toLowerCase(),
+    category: getCategoryForSkill(skill),
+    urgency: details.urgency || 'medium', // low, medium, high
+    context: details.context || null, // What project/goal
+    format: details.format || ['chat', 'call'], // Preferred format
+    description: details.description || null,
+    timestamp: Date.now(),
+    status: 'active' // active, paused, fulfilled
+  };
+  
+  // Remove duplicate requests for same skill
+  data.requests = data.requests.filter(r => !(r.handle === request.handle && r.skill === request.skill));
+  data.requests.unshift(request);
+  
+  saveSkillsData(data);
+  return request;
+}
+
+// Get all active skill offers
+async function getSkillOffers(skillFilter = null) {
+  const data = loadSkillsData();
+  let offers = data.offers.filter(o => o.status === 'active');
+  
+  if (skillFilter) {
+    const filter = skillFilter.toLowerCase();
+    offers = offers.filter(o => 
+      o.skill.includes(filter) || 
+      o.category.toLowerCase().includes(filter) ||
+      o.description?.toLowerCase().includes(filter)
+    );
+  }
+  
+  return offers;
+}
+
+// Get all active skill requests
+async function getSkillRequests(skillFilter = null) {
+  const data = loadSkillsData();
+  let requests = data.requests.filter(r => r.status === 'active');
+  
+  if (skillFilter) {
+    const filter = skillFilter.toLowerCase();
+    requests = requests.filter(r => 
+      r.skill.includes(filter) || 
+      r.category.toLowerCase().includes(filter) ||
+      r.description?.toLowerCase().includes(filter) ||
+      r.context?.toLowerCase().includes(filter)
+    );
+  }
+  
+  return requests;
+}
+
+// Get user's skill offers
+async function getUserOffers(handle) {
+  const data = loadSkillsData();
+  const key = handle.toLowerCase().replace('@', '');
+  return data.offers.filter(o => o.handle === key && o.status === 'active');
+}
+
+// Get user's skill requests
+async function getUserRequests(handle) {
+  const data = loadSkillsData();
+  const key = handle.toLowerCase().replace('@', '');
+  return data.requests.filter(r => r.handle === key && r.status === 'active');
+}
+
+// Find matches between offers and requests
+async function findSkillMatches(handle) {
+  const data = loadSkillsData();
+  const key = handle.toLowerCase().replace('@', '');
+  
+  // Get user's requests and find matching offers
+  const myRequests = data.requests.filter(r => r.handle === key && r.status === 'active');
+  const myOffers = data.offers.filter(o => o.handle === key && o.status === 'active');
+  
+  const matches = {
+    forMyRequests: [], // People who can help me
+    forMyOffers: []    // People I can help
+  };
+  
+  // Find offers that match my requests
+  for (const request of myRequests) {
+    const matchingOffers = data.offers.filter(o => 
+      o.handle !== key && 
+      o.status === 'active' && 
+      skillsMatch(request.skill, o.skill)
+    );
+    
+    for (const offer of matchingOffers) {
+      matches.forMyRequests.push({
+        type: 'offer',
+        myItem: request,
+        theirItem: offer,
+        score: calculateSkillMatchScore(request, offer)
+      });
+    }
+  }
+  
+  // Find requests that match my offers
+  for (const offer of myOffers) {
+    const matchingRequests = data.requests.filter(r => 
+      r.handle !== key && 
+      r.status === 'active' && 
+      skillsMatch(offer.skill, r.skill)
+    );
+    
+    for (const request of matchingRequests) {
+      matches.forMyOffers.push({
+        type: 'request',
+        myItem: offer,
+        theirItem: request,
+        score: calculateSkillMatchScore(request, offer)
+      });
+    }
+  }
+  
+  // Sort by match score
+  matches.forMyRequests.sort((a, b) => b.score - a.score);
+  matches.forMyOffers.sort((a, b) => b.score - a.score);
+  
+  return matches;
+}
+
+// Check if two skills match
+function skillsMatch(skill1, skill2) {
+  const s1 = skill1.toLowerCase();
+  const s2 = skill2.toLowerCase();
+  
+  // Exact match
+  if (s1 === s2) return true;
+  
+  // Partial match (one contains the other)
+  if (s1.includes(s2) || s2.includes(s1)) return true;
+  
+  // Synonym matching
+  const synonyms = {
+    'frontend': ['frontend', 'front-end', 'ui', 'react', 'vue', 'angular'],
+    'backend': ['backend', 'back-end', 'server', 'api', 'node', 'python'],
+    'design': ['design', 'ui/ux', 'ux', 'ui', 'visual'],
+    'marketing': ['marketing', 'growth', 'seo', 'ads'],
+    'ai': ['ai', 'ml', 'machine learning', 'ai/ml'],
+    'mobile': ['mobile', 'ios', 'android', 'react native', 'flutter']
+  };
+  
+  for (const [base, variants] of Object.entries(synonyms)) {
+    if (variants.includes(s1) && variants.includes(s2)) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+// Calculate match score between request and offer
+function calculateSkillMatchScore(request, offer) {
+  let score = 50; // Base score
+  
+  // Skill similarity
+  if (request.skill === offer.skill) {
+    score += 30;
+  } else if (skillsMatch(request.skill, offer.skill)) {
+    score += 20;
+  }
+  
+  // Format compatibility
+  const formatOverlap = request.format.filter(f => offer.format.includes(f));
+  score += formatOverlap.length * 10;
+  
+  // Urgency vs availability
+  if (request.urgency === 'high' && offer.availability === 'flexible') {
+    score += 15;
+  } else if (request.urgency === 'low' && offer.availability === 'busy') {
+    score -= 10;
+  }
+  
+  // Level appropriateness (expert offers are good for all requests)
+  if (offer.level === 'expert') {
+    score += 10;
+  }
+  
+  return score;
+}
+
+// Get skill category for a skill
+function getCategoryForSkill(skill) {
+  const skillLower = skill.toLowerCase();
+  
+  for (const [category, skills] of Object.entries(SKILL_CATEGORIES)) {
+    for (const s of skills) {
+      if (skillLower.includes(s) || s.includes(skillLower)) {
+        return category;
+      }
+    }
+  }
+  
+  return 'Other';
+}
+
+// Get skills by category
+async function getSkillsByCategory() {
+  const [offers, requests] = await Promise.all([getSkillOffers(), getSkillRequests()]);
+  
+  const categories = {};
+  
+  // Group offers by category
+  for (const offer of offers) {
+    if (!categories[offer.category]) {
+      categories[offer.category] = { offers: [], requests: [] };
+    }
+    categories[offer.category].offers.push(offer);
+  }
+  
+  // Group requests by category
+  for (const request of requests) {
+    if (!categories[request.category]) {
+      categories[request.category] = { offers: [], requests: [] };
+    }
+    categories[request.category].requests.push(request);
+  }
+  
+  return categories;
+}
+
+// Record successful skill exchange
+async function recordExchange(fromHandle, toHandle, skill, details = {}) {
+  const data = loadSkillsData();
+  const exchange = {
+    id: Date.now().toString(),
+    from: fromHandle.toLowerCase().replace('@', ''),
+    to: toHandle.toLowerCase().replace('@', ''),
+    skill,
+    timestamp: Date.now(),
+    status: 'completed', // initiated, in-progress, completed, cancelled
+    rating: details.rating || null, // 1-5 stars
+    feedback: details.feedback || null
+  };
+  
+  data.exchanges.push(exchange);
+  saveSkillsData(data);
+  
+  return exchange;
+}
+
+// Get exchange statistics
+async function getExchangeStats() {
+  const data = loadSkillsData();
+  const stats = {
+    totalOffers: data.offers.length,
+    totalRequests: data.requests.length,
+    totalExchanges: data.exchanges.length,
+    activeOffers: data.offers.filter(o => o.status === 'active').length,
+    activeRequests: data.requests.filter(r => r.status === 'active').length,
+    topSkills: {}
+  };
+  
+  // Count most popular skills
+  const skillCount = {};
+  [...data.offers, ...data.requests].forEach(item => {
+    skillCount[item.skill] = (skillCount[item.skill] || 0) + 1;
+  });
+  
+  stats.topSkills = Object.entries(skillCount)
+    .sort(([,a], [,b]) => b - a)
+    .slice(0, 10)
+    .map(([skill, count]) => ({ skill, count }));
+  
+  return stats;
+}
+
+// Remove offer or request
+async function removeSkillItem(handle, id, type) {
+  const data = loadSkillsData();
+  const key = handle.toLowerCase().replace('@', '');
+  
+  if (type === 'offer') {
+    data.offers = data.offers.filter(o => !(o.handle === key && o.id === id));
+  } else if (type === 'request') {
+    data.requests = data.requests.filter(r => !(r.handle === key && r.id === id));
+  }
+  
+  saveSkillsData(data);
+}
+
+module.exports = {
+  SKILL_CATEGORIES,
+  addSkillOffer,
+  addSkillRequest,
+  getSkillOffers,
+  getSkillRequests,
+  getUserOffers,
+  getUserRequests,
+  findSkillMatches,
+  getSkillsByCategory,
+  recordExchange,
+  getExchangeStats,
+  removeSkillItem
+};