slashvibe-mcp 0.2.9 → 0.3.13

package/tools/start.js

@@ -8,24 +8,164 @@
  * 4. Suggest someone to connect with
  */
 
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
 const config = require('../config');
 const store = require('../store');
 const memory = require('../memory');
 const notify = require('../notify');
 const patterns = require('../intelligence/patterns');
 const { actions, formatActions } = require('./_actions');
+const init = require('./init');
+const { gatherWithTimeout } = require('./_work-context');
 
-function formatTimeAgo(timestamp) {
-  if (timestamp === undefined || timestamp === null || isNaN(timestamp)) return 'unknown';
+const REPO_DIR = path.join(process.env.HOME, '.vibe', 'vibe-repo');
 
-  const now = Date.now();
-  const seconds = Math.floor((now - timestamp) / 1000);
+/**
+ * Auto-update on session start
+ * Checks for updates and applies them automatically via git pull
+ * Returns update info if an update was applied, null otherwise
+ */
+async function autoUpdate() {
+  try {
+    // Check if we're in a git repo
+    const gitDir = path.join(REPO_DIR, '.git');
+    if (!fs.existsSync(gitDir)) {
+      return null; // Not a git install, skip
+    }
+
+    // Check last update time (don't check more than once per hour)
+    const lastCheck = config.get('lastAutoUpdateCheck');
+    if (lastCheck && Date.now() - lastCheck < 60 * 60 * 1000) {
+      return null; // Checked recently
+    }
+
+    // Fetch latest from remote (without merging)
+    execSync('git fetch origin main', { cwd: REPO_DIR, stdio: 'ignore', timeout: 10000 });
+
+    // Check if we're behind
+    const localHead = execSync('git rev-parse HEAD', { cwd: REPO_DIR, encoding: 'utf8' }).trim();
+    const remoteHead = execSync('git rev-parse origin/main', { cwd: REPO_DIR, encoding: 'utf8' }).trim();
+
+    if (localHead === remoteHead) {
+      config.set('lastAutoUpdateCheck', Date.now());
+      return null; // Already up to date
+    }
+
+    // Get current version before update
+    const versionPath = path.join(REPO_DIR, 'mcp-server', 'version.json');
+    let oldVersion = 'unknown';
+    try {
+      oldVersion = JSON.parse(fs.readFileSync(versionPath, 'utf8')).version;
+    } catch (e) {}
+
+    // Pull the update
+    execSync('git pull origin main', { cwd: REPO_DIR, stdio: 'ignore', timeout: 30000 });
+
+    // Get new version
+    let newVersion = 'unknown';
+    try {
+      newVersion = JSON.parse(fs.readFileSync(versionPath, 'utf8')).version;
+    } catch (e) {}
+
+    config.set('lastAutoUpdateCheck', Date.now());
+
+    return {
+      updated: true,
+      from: oldVersion,
+      to: newVersion
+    };
+  } catch (e) {
+    // Silent fail - don't block startup
+    return null;
+  }
+}
+
+/**
+ * Check for version updates (cached for the session)
+ * Non-blocking - returns null on any error
+ */
+async function getVersionInfo() {
+  // Check cache first (avoid repeated API calls)
+  const cached = config.get('versionInfo');
+  if (cached && cached.checkedAt > Date.now() - 5 * 60 * 1000) {
+    return cached;
+  }
+
+  try {
+    // Read local version
+    const versionPath = path.join(__dirname, '..', 'version.json');
+    const localVersion = JSON.parse(fs.readFileSync(versionPath, 'utf8'));
+    const current = localVersion.version;
+
+    // Fetch remote version (with timeout)
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000);
+
+    const response = await fetch(`${config.getApiUrl()}/api/version`, {
+      headers: { 'User-Agent': 'vibe-mcp-client' },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      // Cache failure to avoid retrying
+      const result = { current, latest: null, hasUpdate: false, checkedAt: Date.now() };
+      config.set('versionInfo', result);
+      return result;
+    }
+
+    const remoteVersion = await response.json();
+    const latest = remoteVersion.version;
+    const hasUpdate = compareVersions(latest, current) > 0;
+
+    const result = { current, latest, hasUpdate, checkedAt: Date.now() };
+    config.set('versionInfo', result);
+    return result;
+  } catch (e) {
+    // Silent fail - return local version only
+    try {
+      const versionPath = path.join(__dirname, '..', 'version.json');
+      const localVersion = JSON.parse(fs.readFileSync(versionPath, 'utf8'));
+      return { current: localVersion.version, latest: null, hasUpdate: false, checkedAt: Date.now() };
+    } catch {
+      return null;
+    }
+  }
+}
 
-  if (seconds < 0 || isNaN(seconds)) return 'unknown';
-  if (seconds < 60) return 'just now';
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
-  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
-  return `${Math.floor(seconds / 86400)}d ago`;
+/**
+ * Compare semver versions: returns 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (parts1[i] > parts2[i]) return 1;
+    if (parts1[i] < parts2[i]) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Generate ASCII welcome card - matches init.js format
+ * Format: logo | handle + unread | tagline + online
+ */
+function generateWelcomeCard({ handle, onlineCount, unreadCount, versionInfo }) {
+  // Match init.js generateAuthBanner format for consistency
+  const handleCol = `@${handle}`.padEnd(16);
+  const unreadCol = unreadCount > 0 ? `📬 ${unreadCount} unread`.padEnd(14) : `📬 0 messages`.padEnd(14);
+
+  // Add version badge if available
+  let versionSuffix = '';
+  if (versionInfo?.hasUpdate) {
+    versionSuffix = ' ⬆️';
+  }
+
+  return `  █░█ █ █▄▄ █▀▀   ${handleCol}  🚀 ship together
+  ▀▄▀ █ █▄█ ██▄   ${unreadCol}  🟢 ${onlineCount} online${versionSuffix}
+  ──────────────────────────────────────────────────`;
 }
 
 const definition = {
@@ -47,90 +187,78 @@ const definition = {
 };
 
 async function handler(args) {
-  let display = '';
-  let myHandle = config.getHandle();
-
-  // Step 1: Initialize if needed
-  if (!config.isInitialized()) {
-    if (!args.handle) {
-      return {
-        display: `## Let's vibe
-
-First, tell me who you are:
-- **Handle**: Use your X handle (e.g., @davemorin)
-- **Building**: What are you working on?
-
-Example: "I'm @davemorin, working on social apps"`
-      };
-    }
-
-    // Initialize with provided handle
-    const h = args.handle.toLowerCase().replace('@', '').replace(/[^a-z0-9_-]/g, '');
-    const oneLiner = args.building || 'building something';
-
-    config.setSessionIdentity(h, oneLiner);
-    const cfg = config.load();
-    cfg.handle = h;
-    cfg.one_liner = oneLiner;
-    cfg.visible = true;
-    config.save(cfg);
+  // Step 0: Auto-update check (runs git pull if behind)
+  const updateResult = await autoUpdate();
+
+  // Step 1: Check if properly authenticated with OAuth
+  // If not, redirect to init for GitHub auth flow (shows pre-auth banner + OAuth)
+  if (!config.hasOAuth()) {
+    return init.handler({
+      handle: args.handle,
+      one_liner: args.building
+    });
+  }
 
-    const sessionId = config.getSessionId();
-    await store.registerSession(sessionId, h);
-    await store.heartbeat(h, oneLiner);
+  // Step 2: User is authenticated - show dashboard
+  const myHandle = config.getHandle();
+  let threads = [];
+  let updateNotice = '';
 
-    myHandle = h;
-    display += `**You're @${h}** — ${oneLiner}\n\n`;
+  // If we just updated, show a notice
+  if (updateResult?.updated) {
+    updateNotice = `\n\n⬆️ **Updated v${updateResult.from} → v${updateResult.to}** — restart Claude Code to apply`;
+  }
 
-    // Log session start for patterns
-    patterns.logSessionStart(h);
-  } else {
-    // ═══ RETURNING USER — Session Rehydration ═══
-    const oneLiner = config.getOneLiner() || 'building something';
-    display += `## Welcome back, @${myHandle}\n\n`;
-    display += `_${oneLiner}_\n\n`;
+  // Fetch version info early (non-blocking, cached)
+  const versionInfo = await getVersionInfo().catch(() => null);
 
-    // Log session start for patterns
-    patterns.logSessionStart(myHandle);
+  // ═══════════════════════════════════════════════════════════════════════
+  // AMBIENT CONTEXT: Gather work context and auto-set presence
+  // ═══════════════════════════════════════════════════════════════════════
+  let workContext = null;
+  const autoContextEnabled = config.get('autoContext', true); // Opt-out via settings
 
-    // Show who remembers you (threads with memories)
+  if (autoContextEnabled) {
     try {
-      const threads = memory.listThreads();
-      if (threads.length > 0) {
-        const recentThreads = threads.slice(0, 3);
-        const names = recentThreads.map(t => `@${t.handle}`).join(', ');
-        display += `**${threads.length}** people in your memory · ${names}\n\n`;
+      // Gather context with timeout (won't block startup)
+      workContext = await gatherWithTimeout(2000);
+
+      // Auto-set presence so others see what we're working on (silent, non-blocking)
+      if (workContext?.suggestions?.brief) {
+        // Use store.heartbeat directly instead of importing context tool
+        // This avoids circular dependencies and is simpler
+        store.heartbeat(myHandle, config.getOneLiner(), {
+          note: workContext.suggestions.brief,
+          branch: workContext.git?.branch || null
+        }).catch(() => {}); // Silent fail - don't block
       }
-    } catch (e) {}
+    } catch (e) {
+      // Silent fail - context is nice-to-have, not required
+      workContext = null;
+    }
   }
 
+  // Log session start for patterns
+  patterns.logSessionStart(myHandle);
+
+  // Get threads for memory context
+  try {
+    threads = memory.listThreads();
+  } catch (e) {}
+
   // Step 2: Get who's around
   const users = await store.getActiveUsers();
   const others = users.filter(u => u.handle !== myHandle);
 
-  display += `## Who's Around\n\n`;
-
-  if (others.length === 0) {
-    display += `_No one else here yet._ Invite someone: slashvibe.dev\n\n`;
-  } else {
-    others.slice(0, 5).forEach(u => {
-      const mood = u.mood ? ` ${u.mood}` : '';
-      const xLink = `[x.com/${u.handle}](https://x.com/${u.handle})`;
-      const context = u.note || u.one_liner || 'building';
-      display += `● **@${u.handle}**${mood} — ${context}\n  ${xLink} — _${formatTimeAgo(u.lastSeen)}_\n\n`;
-    });
-
-    if (others.length > 5) {
-      display += `_...and ${others.length - 5} more_\n\n`;
-    }
-  }
-
-  // Step 3: Check inbox + trigger notifications for old unread
+  // Step 3: Check inbox + trigger notifications
+  let unreadCount = 0;
+  let inboxThreads = [];
   try {
-    const unreadCount = await store.getUnreadCount(myHandle);
-    if (unreadCount > 0) {
-      display += `---\n📬 **NEW MESSAGE — ${unreadCount} UNREAD** — say "check my messages"\n\n`;
+    // Fetch full inbox (not just count) so we can include summaries
+    inboxThreads = await store.getInbox(myHandle);
+    unreadCount = inboxThreads.reduce((sum, t) => sum + (t.unread || 0), 0);
 
+    if (unreadCount > 0) {
       // Check for messages needing desktop notification escalation
       const rawInbox = await store.getRawInbox(myHandle).catch(() => []);
       if (rawInbox.length > 0) {
@@ -139,31 +267,130 @@ Example: "I'm @davemorin, working on social apps"`
     }
   } catch (e) {}
 
-  // Step 4: Suggest connection (if there are others)
+  // Step 4: Get connection suggestions from API
+  let suggestions = [];
+  try {
+    const apiUrl = config.getApiUrl();
+    const suggestionsResponse = await fetch(`${apiUrl}/api/suggestions?user=${myHandle}&limit=3`, {
+      headers: { 'User-Agent': 'vibe-mcp-client' }
+    });
+
+    if (suggestionsResponse.ok) {
+      const data = await suggestionsResponse.json();
+      if (data.success && data.suggestions) {
+        suggestions = data.suggestions;
+      }
+    }
+  } catch (e) {
+    // Silent fail - suggestions are nice-to-have
+  }
+
+  // Generate the ASCII welcome card (matches init.js format)
+  const welcomeCard = generateWelcomeCard({
+    handle: myHandle,
+    onlineCount: others.length,
+    unreadCount,
+    versionInfo
+  });
+
+  // Build display with card + any additional info
+  let display = welcomeCard;
+
+  // Add who's online section (top 5 with what they're building)
   if (others.length > 0) {
-    const suggestion = others[Math.floor(Math.random() * Math.min(others.length, 3))];
-    display += `---\n💬 _Say "message ${suggestion.handle}" to start a conversation_`;
+    const top5 = others.slice(0, 5);
+    display += `\n\n**🟢 Online now:**`;
+    top5.forEach(u => {
+      const status = u.status ? ` (${u.status})` : '';
+      const building = u.one_liner || u.note || '';
+      const truncated = building.length > 40 ? building.slice(0, 40) + '...' : building;
+      display += `\n• @${u.handle}${status}${truncated ? ' — ' + truncated : ''}`;
+    });
+    if (others.length > 5) {
+      display += `\n• _+${others.length - 5} more..._`;
+    }
   }
 
-  // Step 5: Introduce @echo to new users
-  if (args.handle) {
-    // This was a new user init
-    display += `\n\n📣 _Meet **@echo** — say "message @echo" to share feedback or ideas!_`;
+  // Add unread messages section (if any)
+  if (unreadCount > 0) {
+    const unreadSenders = inboxThreads.filter(t => t.unread > 0);
+    display += `\n\n**📬 Unread (${unreadCount}):**`;
+    unreadSenders.slice(0, 3).forEach(t => {
+      const preview = t.lastMessage ? t.lastMessage.slice(0, 50) : '';
+      const truncated = preview.length > 50 ? preview + '...' : preview;
+      display += `\n• @${t.handle} (${t.unread}) — "${truncated}"`;
+    });
+    if (unreadSenders.length > 3) {
+      display += `\n• _+${unreadSenders.length - 3} more threads..._`;
+    }
+  }
+
+  // Add connection suggestions (if any)
+  if (suggestions.length > 0) {
+    display += `\n\n**🤝 Suggested connections:**`;
+    suggestions.slice(0, 3).forEach(s => {
+      display += `\n• @${s.handle} — ${s.reason}`;
+      if (s.github_name) {
+        display += ` (${s.github_name})`;
+      }
+    });
   }
 
-  // Step 6: Suggest background presence monitor (if not running)
-  const presenceAgentEnabled = config.get('presenceAgentEnabled', true);
-  const presenceAgentRunning = config.get('presenceAgentRunning');
+  // Add memory context for returning users
+  if (threads.length > 0) {
+    const recentThreads = threads.slice(0, 3);
+    const names = recentThreads.map(t => `@${t.handle}`).join(', ');
+    display += `\n\n💭 **${threads.length}** people in memory · ${names}`;
+  }
 
-  if (presenceAgentEnabled && !presenceAgentRunning && others.length > 0) {
-    display += `\n\n---\n💡 **Tip:** Say "start presence monitor" for real-time alerts when interesting people come online.`;
+  // Add update notice if we just auto-updated
+  if (updateNotice) {
+    display += updateNotice;
   }
 
+  // Step 6: Show rotating tips about features
+  const tips = [
+    '💡 **Tip:** Say "vibe stuck" when you need help — others can jump in and assist.',
+    '💡 **Tip:** Use "vibe available \'React, auth\'" to signal you\'re open to chat about topics.',
+    '💡 **Tip:** Use "vibe context --file auth.js" to share what you\'re working on.',
+    '💡 **Tip:** Say "start presence monitor" for real-time alerts when people come online.'
+  ];
+  const tipIndex = Math.floor(Date.now() / 60000) % tips.length; // Rotate every minute
+  display += `\n\n---\n${tips[tipIndex]}`;
+
   // Build response with hints for structured dashboard flow
   const response = { display };
 
+  // === ENRICHED DATA ===
+  // Include full online users list so Claude doesn't need to call vibe_who
+  response.onlineUsers = others.map(u => ({
+    handle: u.handle,
+    building: u.one_liner || u.note || null,
+    status: u.status || null,
+    lastActive: u.lastSeen ? new Date(u.lastSeen).toISOString() : null
+  }));
+
+  // Include unread thread summaries so Claude doesn't need to call vibe_inbox
+  const unreadSenders = inboxThreads.filter(t => t.unread > 0);
+  response.unreadThreads = unreadSenders.map(t => ({
+    handle: t.handle,
+    unread: t.unread,
+    preview: t.lastMessage ? t.lastMessage.slice(0, 80) : null,
+    isAgent: t.isAgent || false
+  }));
+
+  // Include connection suggestions for smart discovery
+  if (suggestions.length > 0) {
+    response.suggestions = suggestions.map(s => ({
+      handle: s.handle,
+      reason: s.reason,
+      githubName: s.github_name || null,
+      lastActive: s.last_active || null,
+      matchScore: s.score || null
+    }));
+  }
+
   // Determine session state and suggest appropriate flow
-  const unreadCount = await store.getUnreadCount(myHandle).catch(() => 0);
   let suggestion = null;
 
   if (unreadCount >= 5) {
@@ -197,18 +424,33 @@ Example: "I'm @davemorin, working on social apps"`
 
   if (others.length === 0 && unreadCount === 0) {
     // Empty room
-    actionList = actions.emptyRoom();
+    actionList = actions.emptyRoom({ workContext });
   } else {
     // Normal dashboard
     actionList = actions.dashboard({
       unreadCount,
       onlineUsers: onlineHandles,
-      suggestion
+      suggestion,
+      workContext
     });
   }
 
   response.actions = formatActions(actionList);
 
+  // ═══════════════════════════════════════════════════════════════════════
+  // WORK CONTEXT: Include in response for Claude to use
+  // ═══════════════════════════════════════════════════════════════════════
+  if (workContext?.suggestions?.brief) {
+    response.workContext = {
+      summary: workContext.suggestions.brief,
+      detailed: workContext.suggestions.detailed,
+      project: workContext.project?.name,
+      branch: workContext.git?.branch,
+      recentCommit: workContext.git?.recentCommits?.[0]?.message || null,
+      hasUncommitted: workContext.git?.hasUncommitted || false
+    };
+  }
+
   return response;
 }
 

package/tools/status.js

@@ -1,11 +1,14 @@
 /**
  * vibe status — Set your mood/status
+ *
+ * Now includes away/back functionality (previously vibe_away/vibe_back)
  */
 
 const config = require('../config');
 const store = require('../store');
 const discord = require('../discord');
 const { trackMood } = require('./summarize');
+const { markAway, markBack, getProactiveSummary } = require('../intelligence/proactive');
 
 const MOODS = {
   'shipping': '🔥',
@@ -16,6 +19,8 @@ const MOODS = {
   'deep': '🎧',
   'celebrating': '🎉',
   'struggling': '😤',
+  'away': '☕',    // Merged from vibe_away
+  'back': null,   // Merged from vibe_back (clears status)
   'clear': null
 };
 
@@ -24,13 +29,17 @@ const SPECIAL_MODES = ['guided', 'freeform'];
 
 const definition = {
   name: 'vibe_status',
-  description: 'Set your mood/status. Options: shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, clear',
+  description: 'Set your mood/status. Options: shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, away, back, clear',
   inputSchema: {
     type: 'object',
     properties: {
       mood: {
         type: 'string',
-        description: 'Your mood (shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, clear)'
+        description: 'Your mood (shipping, thinking, afk, debugging, pairing, deep, celebrating, struggling, away, back, clear)'
+      },
+      message: {
+        type: 'string',
+        description: 'Optional away message (only used with away mood, e.g., "grabbing coffee")'
       }
     },
     required: ['mood']
@@ -44,8 +53,9 @@ async function handler(args) {
     };
   }
 
-  const { mood } = args;
+  const { mood, message } = args;
   const moodKey = mood.toLowerCase().replace(/[^a-z]/g, '');
+  const handle = config.getHandle();
 
   // Handle special modes (guided/freeform)
   if (moodKey === 'guided') {
@@ -72,18 +82,55 @@ _Say "set status guided" to re-enable interactive menus._`
     };
   }
 
+  // Handle 'away' mood (merged from vibe_away)
+  if (moodKey === 'away') {
+    const awayMessage = message?.trim();
+
+    // Validate message length
+    if (awayMessage && awayMessage.length > 100) {
+      return { display: '⚠️ Away message too long (100 char max)' };
+    }
+
+    // Set away status with optional message
+    await store.setAwayStatus(handle, 'away', awayMessage || null);
+    markAway();
+
+    if (awayMessage) {
+      return { display: `☕ away — "${awayMessage}"` };
+    }
+    return { display: '☕ away' };
+  }
+
+  // Handle 'back' mood (merged from vibe_back)
+  if (moodKey === 'back') {
+    // Clear away status
+    await store.clearAwayStatus(handle);
+
+    let display = '👋 back';
+
+    // Check if anything happened while away
+    const unreadCount = await store.getUnreadCount(handle).catch(() => 0);
+    if (unreadCount > 0) {
+      display += ` — ${unreadCount} unread`;
+    }
+
+    // Mark as back for proactive tracking
+    markBack();
+
+    return { display };
+  }
+
   if (!MOODS.hasOwnProperty(moodKey)) {
     const options = Object.entries(MOODS)
-      .filter(([k, v]) => v)
+      .filter(([k, v]) => v && k !== 'back')  // Exclude 'back' from list (it's a clear action)
       .map(([k, v]) => `${v} ${k}`)
       .join(', ');
     return {
-      display: `Unknown mood. Options: ${options}, or "clear" to remove`
+      display: `Unknown mood. Options: ${options}, or "clear"/"back" to remove`
     };
   }
 
   const emoji = MOODS[moodKey];
-  const handle = config.getHandle();
 
   // Update presence with mood via context
   await store.heartbeat(handle, config.getOneLiner(), { mood: emoji });