slashvibe-mcp 0.3.21 → 0.3.23

package/store/skills.js

@@ -17,12 +17,12 @@ 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']
+  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
@@ -63,11 +63,11 @@ async function addSkillOffer(handle, skill, details = {}) {
     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;
 }
@@ -87,11 +87,11 @@ async function addSkillRequest(handle, skill, details = {}) {
     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;
 }
@@ -100,16 +100,17 @@ async function addSkillRequest(handle, skill, details = {}) {
 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)
+    offers = offers.filter(
+      o =>
+        o.skill.includes(filter) ||
+        o.category.toLowerCase().includes(filter) ||
+        o.description?.toLowerCase().includes(filter)
     );
   }
-  
+
   return offers;
 }
 
@@ -117,17 +118,18 @@ async function getSkillOffers(skillFilter = null) {
 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)
+    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;
 }
 
@@ -149,24 +151,22 @@ async function getUserRequests(handle) {
 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
+    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)
+    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',
@@ -176,15 +176,13 @@ async function findSkillMatches(handle) {
       });
     }
   }
-  
+
   // 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)
+    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',
@@ -194,11 +192,11 @@ async function findSkillMatches(handle) {
       });
     }
   }
-  
+
   // Sort by match score
   matches.forMyRequests.sort((a, b) => b.score - a.score);
   matches.forMyOffers.sort((a, b) => b.score - a.score);
-  
+
   return matches;
 }
 
@@ -206,66 +204,66 @@ async function findSkillMatches(handle) {
 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']
+    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)) {
@@ -273,16 +271,16 @@ function getCategoryForSkill(skill) {
       }
     }
   }
-  
+
   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]) {
@@ -290,7 +288,7 @@ async function getSkillsByCategory() {
     }
     categories[offer.category].offers.push(offer);
   }
-  
+
   // Group requests by category
   for (const request of requests) {
     if (!categories[request.category]) {
@@ -298,7 +296,7 @@ async function getSkillsByCategory() {
     }
     categories[request.category].requests.push(request);
   }
-  
+
   return categories;
 }
 
@@ -315,10 +313,10 @@ async function recordExchange(fromHandle, toHandle, skill, details = {}) {
     rating: details.rating || null, // 1-5 stars
     feedback: details.feedback || null
   };
-  
+
   data.exchanges.push(exchange);
   saveSkillsData(data);
-  
+
   return exchange;
 }
 
@@ -333,18 +331,18 @@ async function getExchangeStats() {
     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)
+    .sort(([, a], [, b]) => b - a)
     .slice(0, 10)
     .map(([skill, count]) => ({ skill, count }));
-  
+
   return stats;
 }
 
@@ -352,13 +350,13 @@ async function getExchangeStats() {
 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);
 }
 
@@ -375,4 +373,4 @@ module.exports = {
   recordExchange,
   getExchangeStats,
   removeSkillItem
-};
+};

package/store/sqlite.js

@@ -0,0 +1,355 @@
+/**
+ * SQLite Message Store - Local persistence for v2 messaging
+ *
+ * Shares database with Vibe Terminal app at ~/.vibecodings/sessions.db
+ * Schema matches src-tauri/src/db.rs exactly (LocalMessage struct)
+ */
+
+const Database = require('better-sqlite3');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const { randomUUID } = require('crypto');
+
+const DB_PATH = path.join(os.homedir(), '.vibecodings', 'sessions.db');
+
+class MessageStore {
+  constructor() {
+    // Ensure directory exists
+    const dir = path.dirname(DB_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    this.db = new Database(DB_PATH);
+
+    // Enable WAL mode for better concurrency with Tauri app
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('busy_timeout = 5000');
+    this.db.pragma('synchronous = NORMAL');
+
+    // Ensure messages table exists (should already exist from Tauri, but just in case)
+    this.ensureSchema();
+
+    // Prepare statements for performance
+    this.prepareStatements();
+  }
+
+  ensureSchema() {
+    // This matches the Tauri schema + V2 Postgres fields
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        local_id TEXT PRIMARY KEY,
+        server_id TEXT,
+        thread_id TEXT,
+        from_handle TEXT NOT NULL,
+        to_handle TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        status TEXT NOT NULL CHECK(status IN ('pending', 'sent', 'delivered', 'read', 'failed')),
+        sent_at TEXT,
+        delivered_at TEXT,
+        read_at TEXT,
+        synced_at TEXT,
+        retry_count INTEGER DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_thread
+      ON messages(from_handle, to_handle, created_at);
+
+      CREATE INDEX IF NOT EXISTS idx_messages_thread_id
+      ON messages(thread_id);
+
+      CREATE INDEX IF NOT EXISTS idx_messages_server_id
+      ON messages(server_id);
+
+      CREATE INDEX IF NOT EXISTS idx_messages_status
+      ON messages(status);
+
+      CREATE INDEX IF NOT EXISTS idx_messages_synced
+      ON messages(synced_at);
+    `);
+  }
+
+  prepareStatements() {
+    this.stmts = {
+      insert: this.db.prepare(`
+        INSERT OR REPLACE INTO messages
+        (local_id, server_id, thread_id, from_handle, to_handle, content, created_at, status,
+         sent_at, delivered_at, read_at, synced_at, retry_count)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `),
+
+      getThread: this.db.prepare(`
+        SELECT local_id, server_id, thread_id, from_handle, to_handle, content, created_at,
+               status, sent_at, delivered_at, read_at, synced_at, retry_count
+        FROM messages
+        WHERE (from_handle = ? AND to_handle = ?)
+           OR (from_handle = ? AND to_handle = ?)
+        ORDER BY created_at ASC
+        LIMIT ?
+      `),
+
+      updateStatus: this.db.prepare(`
+        UPDATE messages
+        SET status = ?, server_id = COALESCE(?, server_id), thread_id = COALESCE(?, thread_id), sent_at = COALESCE(?, sent_at)
+        WHERE local_id = ?
+      `),
+
+      getInboxThreads: this.db.prepare(`
+        WITH thread_partners AS (
+          SELECT DISTINCT
+            CASE WHEN from_handle = ? THEN to_handle ELSE from_handle END as partner
+          FROM messages
+          WHERE from_handle = ? OR to_handle = ?
+        ),
+        latest_messages AS (
+          SELECT
+            CASE WHEN from_handle = ? THEN to_handle ELSE from_handle END as partner,
+            local_id, server_id, from_handle, to_handle, content, created_at,
+            status, sent_at, delivered_at, read_at, synced_at, retry_count,
+            ROW_NUMBER() OVER (PARTITION BY CASE WHEN from_handle = ? THEN to_handle ELSE from_handle END
+                               ORDER BY created_at DESC) as rn
+          FROM messages
+          WHERE from_handle = ? OR to_handle = ?
+        ),
+        unread_counts AS (
+          SELECT
+            CASE WHEN to_handle = ? THEN from_handle ELSE to_handle END as partner,
+            COUNT(*) as unread
+          FROM messages
+          WHERE to_handle = ? AND status IN ('sent', 'delivered')
+          GROUP BY partner
+        )
+        SELECT
+          lm.partner, lm.local_id, lm.server_id, lm.from_handle, lm.to_handle,
+          lm.content, lm.created_at, lm.status, lm.sent_at, lm.delivered_at,
+          lm.read_at, lm.synced_at, lm.retry_count,
+          COALESCE(uc.unread, 0) as unread_count
+        FROM latest_messages lm
+        LEFT JOIN unread_counts uc ON lm.partner = uc.partner
+        WHERE lm.rn = 1
+        ORDER BY lm.created_at DESC
+      `),
+
+      markThreadRead: this.db.prepare(`
+        UPDATE messages
+        SET status = 'read', read_at = ?
+        WHERE from_handle = ? AND to_handle = ? AND status IN ('sent', 'delivered')
+      `)
+    };
+  }
+
+  /**
+   * Save a local message (optimistic - before server confirmation)
+   */
+  saveLocalMessage(message) {
+    const {
+      local_id = randomUUID(),
+      server_id = null,
+      thread_id = null,
+      from_handle,
+      to_handle,
+      content,
+      created_at = new Date().toISOString(),
+      status = 'pending',
+      sent_at = null,
+      delivered_at = null,
+      read_at = null,
+      synced_at = null,
+      retry_count = 0
+    } = message;
+
+    this.stmts.insert.run(
+      local_id,
+      server_id,
+      thread_id,
+      from_handle,
+      to_handle,
+      content,
+      created_at,
+      status,
+      sent_at,
+      delivered_at,
+      read_at,
+      synced_at,
+      retry_count
+    );
+
+    return local_id;
+  }
+
+  /**
+   * Get messages for a thread between two users
+   */
+  getThreadMessages(handle1, handle2, limit = 100) {
+    return this.stmts.getThread.all(handle1, handle2, handle2, handle1, limit).map(row => ({
+      local_id: row.local_id,
+      server_id: row.server_id,
+      thread_id: row.thread_id,
+      from_handle: row.from_handle,
+      to_handle: row.to_handle,
+      content: row.content,
+      created_at: row.created_at,
+      status: row.status,
+      sent_at: row.sent_at,
+      delivered_at: row.delivered_at,
+      read_at: row.read_at,
+      synced_at: row.synced_at,
+      retry_count: row.retry_count
+    }));
+  }
+
+  /**
+   * Update message status after server response
+   */
+  updateMessageStatus(local_id, status, server_id = null, thread_id = null) {
+    const sent_at = status === 'sent' || status === 'delivered' || status === 'read' ? new Date().toISOString() : null;
+
+    this.stmts.updateStatus.run(status, server_id, thread_id, sent_at, local_id);
+  }
+
+  /**
+   * Merge server messages into local cache (V2 Postgres format)
+   * Uses INSERT OR IGNORE to avoid overwriting local changes
+   */
+  mergeServerMessages(messages) {
+    const insert = this.db.prepare(`
+      INSERT OR IGNORE INTO messages
+      (local_id, server_id, thread_id, from_handle, to_handle, content, created_at, status,
+       sent_at, delivered_at, read_at, synced_at, retry_count)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    const transaction = this.db.transaction(msgs => {
+      for (const msg of msgs) {
+        insert.run(
+          msg.local_id || msg.id || randomUUID(), // Handle both formats
+          msg.server_id || msg.id,
+          msg.thread_id, // V2 Postgres thread_id
+          msg.from_handle || msg.from,
+          msg.to_handle || msg.to,
+          msg.content || msg.body || msg.text || '',
+          msg.created_at || msg.createdAt || new Date().toISOString(),
+          msg.status || 'delivered',
+          msg.sent_at || msg.sentAt || msg.created_at || msg.createdAt,
+          msg.delivered_at || msg.deliveredAt,
+          msg.read_at || msg.readAt,
+          new Date().toISOString(), // synced_at
+          0 // retry_count
+        );
+      }
+    });
+
+    transaction(messages);
+    return messages.length;
+  }
+
+  /**
+   * Get inbox threads for a user
+   */
+  getInboxThreads(handle) {
+    const rows = this.stmts.getInboxThreads.all(
+      handle,
+      handle,
+      handle, // thread_partners CTE
+      handle,
+      handle,
+      handle,
+      handle, // latest_messages CTE
+      handle,
+      handle // unread_counts CTE
+    );
+
+    return rows.map(row => ({
+      partner: row.partner,
+      latestMessage: {
+        local_id: row.local_id,
+        server_id: row.server_id,
+        from_handle: row.from_handle,
+        to_handle: row.to_handle,
+        content: row.content,
+        created_at: row.created_at,
+        status: row.status,
+        sent_at: row.sent_at,
+        delivered_at: row.delivered_at,
+        read_at: row.read_at,
+        synced_at: row.synced_at,
+        retry_count: row.retry_count
+      },
+      unreadCount: row.unread_count
+    }));
+  }
+
+  /**
+   * Mark all messages in a thread as read
+   */
+  markThreadRead(my_handle, other_handle) {
+    const now = new Date().toISOString();
+    const result = this.stmts.markThreadRead.run(now, other_handle, my_handle);
+    return result.changes;
+  }
+
+  /**
+   * Get pending/failed messages for retry
+   */
+  getPendingMessages() {
+    const rows = this.db
+      .prepare(
+        `
+      SELECT local_id, server_id, from_handle, to_handle, content, created_at,
+             status, sent_at, delivered_at, read_at, synced_at, retry_count
+      FROM messages
+      WHERE status = 'pending' OR status = 'failed'
+      ORDER BY created_at ASC
+    `
+      )
+      .all();
+
+    return rows.map(row => ({
+      local_id: row.local_id,
+      server_id: row.server_id,
+      from_handle: row.from_handle,
+      to_handle: row.to_handle,
+      content: row.content,
+      created_at: row.created_at,
+      status: row.status,
+      sent_at: row.sent_at,
+      delivered_at: row.delivered_at,
+      read_at: row.read_at,
+      synced_at: row.synced_at,
+      retry_count: row.retry_count
+    }));
+  }
+
+  close() {
+    this.db.close();
+  }
+}
+
+// Export singleton instance
+let instance = null;
+
+function getInstance() {
+  if (!instance) {
+    try {
+      instance = new MessageStore();
+    } catch (error) {
+      console.error('[SQLite] Failed to initialize:', error.message);
+      // Return stub with no-op methods if SQLite fails
+      return {
+        saveLocalMessage: () => randomUUID(),
+        getThreadMessages: () => [],
+        updateMessageStatus: () => {},
+        mergeServerMessages: () => 0,
+        getInboxThreads: () => [],
+        markThreadRead: () => 0,
+        getPendingMessages: () => [],
+        close: () => {}
+      };
+    }
+  }
+  return instance;
+}
+
+module.exports = getInstance();