slashvibe-mcp 0.3.20 → 0.3.21

package/smart-inbox.js

@@ -0,0 +1,276 @@
+/**
+ * Smart Inbox Checking
+ *
+ * Intelligent notification checking that triggers at natural breaks:
+ * - After git commits
+ * - After test/build completion
+ * - After periods of activity (not idle)
+ * - On explicit check request
+ *
+ * Uses debouncing to avoid notification spam.
+ */
+
+const config = require('./config');
+const notify = require('./notify');
+const store = require('./store');
+const fs = require('fs');
+const path = require('path');
+
+// State file for tracking check timing
+const SMART_STATE_FILE = path.join(config.VIBE_DIR, '.smart_inbox_state.json');
+
+// Timing constants
+const MIN_CHECK_INTERVAL = 60 * 1000;       // Minimum 1 minute between checks
+const ACTIVITY_COOLDOWN = 5 * 60 * 1000;    // 5 min after activity burst
+const COMMIT_DELAY = 3 * 1000;              // 3 second delay after commit (let it settle)
+const TEST_DELAY = 2 * 1000;                // 2 second delay after test
+const BUILD_DELAY = 5 * 1000;               // 5 second delay after build
+
+// Trigger types
+const TRIGGERS = {
+  COMMIT: 'commit',
+  TEST_PASS: 'test_pass',
+  TEST_FAIL: 'test_fail',
+  BUILD_COMPLETE: 'build_complete',
+  BUILD_FAIL: 'build_fail',
+  NATURAL_BREAK: 'natural_break',
+  EXPLICIT: 'explicit',
+  SESSION_START: 'session_start',
+  SESSION_END: 'session_end',
+};
+
+function loadState() {
+  try {
+    if (fs.existsSync(SMART_STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(SMART_STATE_FILE, 'utf8'));
+    }
+  } catch (e) {}
+  return {
+    lastCheck: null,
+    lastTrigger: null,
+    checkCount: 0,
+    triggersToday: {},
+    activityBurst: null,
+  };
+}
+
+function saveState(state) {
+  try {
+    fs.writeFileSync(SMART_STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {}
+}
+
+/**
+ * Check if we should actually run a check based on timing
+ */
+function shouldCheck(trigger) {
+  const state = loadState();
+  const now = Date.now();
+
+  // Always allow explicit checks
+  if (trigger === TRIGGERS.EXPLICIT) {
+    return { should: true, reason: 'explicit_request' };
+  }
+
+  // Check minimum interval
+  if (state.lastCheck && (now - state.lastCheck) < MIN_CHECK_INTERVAL) {
+    return { should: false, reason: 'too_soon', wait: MIN_CHECK_INTERVAL - (now - state.lastCheck) };
+  }
+
+  // Session events always trigger
+  if (trigger === TRIGGERS.SESSION_START || trigger === TRIGGERS.SESSION_END) {
+    return { should: true, reason: 'session_event' };
+  }
+
+  // For build/test/commit, we want them but with debounce
+  if ([TRIGGERS.COMMIT, TRIGGERS.TEST_PASS, TRIGGERS.TEST_FAIL,
+       TRIGGERS.BUILD_COMPLETE, TRIGGERS.BUILD_FAIL].includes(trigger)) {
+    // If same trigger happened in last 30 seconds, skip
+    if (state.lastTrigger === trigger && state.lastCheck && (now - state.lastCheck) < 30000) {
+      return { should: false, reason: 'debounced', wait: 30000 - (now - state.lastCheck) };
+    }
+    return { should: true, reason: 'event_trigger' };
+  }
+
+  // Natural breaks - check if there's been activity recently
+  if (trigger === TRIGGERS.NATURAL_BREAK) {
+    // If we haven't checked in 5+ minutes and there's been activity, good time
+    if (!state.lastCheck || (now - state.lastCheck) > ACTIVITY_COOLDOWN) {
+      return { should: true, reason: 'natural_break' };
+    }
+    return { should: false, reason: 'not_time_yet' };
+  }
+
+  return { should: true, reason: 'default' };
+}
+
+/**
+ * Perform smart inbox check
+ * Returns notification info if any
+ */
+async function check(trigger = TRIGGERS.EXPLICIT, context = {}) {
+  const decision = shouldCheck(trigger);
+
+  if (!decision.should) {
+    return {
+      checked: false,
+      reason: decision.reason,
+      waitMs: decision.wait || 0,
+    };
+  }
+
+  const handle = config.getHandle();
+  if (!handle) {
+    return { checked: false, reason: 'not_initialized' };
+  }
+
+  const state = loadState();
+  const now = Date.now();
+
+  // Apply appropriate delay based on trigger
+  let delay = 0;
+  switch (trigger) {
+    case TRIGGERS.COMMIT:
+      delay = COMMIT_DELAY;
+      break;
+    case TRIGGERS.TEST_PASS:
+    case TRIGGERS.TEST_FAIL:
+      delay = TEST_DELAY;
+      break;
+    case TRIGGERS.BUILD_COMPLETE:
+    case TRIGGERS.BUILD_FAIL:
+      delay = BUILD_DELAY;
+      break;
+  }
+
+  if (delay > 0) {
+    await new Promise(r => setTimeout(r, delay));
+  }
+
+  // Run the actual notification check
+  let unreadCount = 0;
+  let notified = false;
+  let newUsers = [];
+  let newShips = [];
+
+  try {
+    // Get unread messages
+    const inbox = await store.getRawInbox(handle).catch(() => []);
+    unreadCount = inbox.length;
+
+    if (inbox.length > 0) {
+      notified = await notify.checkAndNotify(inbox);
+    }
+
+    // Get presence for online users
+    const users = await store.getActiveUsers().catch(() => []);
+    if (users.length > 0) {
+      newUsers = notify.checkPresence(users);
+    }
+
+    // Get ships from connections
+    try {
+      const localStore = require('./store/local');
+      const memories = localStore.getAllThreadMemories ? localStore.getAllThreadMemories() : {};
+      const memoryHandles = Object.keys(memories).map(h => h.toLowerCase());
+      if (memoryHandles.length > 0) {
+        newShips = await notify.checkShips(memoryHandles);
+      }
+    } catch (e) {
+      // Memory check is optional
+    }
+  } catch (e) {
+    // Silent fail
+  }
+
+  // Update state
+  state.lastCheck = now;
+  state.lastTrigger = trigger;
+  state.checkCount++;
+
+  // Track triggers by day
+  const today = new Date().toISOString().split('T')[0];
+  if (!state.triggersToday || state.triggersToday.date !== today) {
+    state.triggersToday = { date: today, counts: {} };
+  }
+  state.triggersToday.counts[trigger] = (state.triggersToday.counts[trigger] || 0) + 1;
+
+  saveState(state);
+
+  return {
+    checked: true,
+    trigger,
+    reason: decision.reason,
+    unreadCount,
+    notified,
+    newOnline: newUsers.map(u => u.handle),
+    newShips: newShips.map(s => s.author),
+    context,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+/**
+ * Trigger after git commit
+ */
+async function afterCommit(commitMessage = '', branch = '') {
+  return check(TRIGGERS.COMMIT, { commitMessage, branch });
+}
+
+/**
+ * Trigger after test completion
+ */
+async function afterTest(passed = true, testOutput = '') {
+  const trigger = passed ? TRIGGERS.TEST_PASS : TRIGGERS.TEST_FAIL;
+  return check(trigger, { passed, testOutput: testOutput.slice(0, 200) });
+}
+
+/**
+ * Trigger after build completion
+ */
+async function afterBuild(success = true, buildOutput = '') {
+  const trigger = success ? TRIGGERS.BUILD_COMPLETE : TRIGGERS.BUILD_FAIL;
+  return check(trigger, { success, buildOutput: buildOutput.slice(0, 200) });
+}
+
+/**
+ * Trigger on natural break (between tasks, file saves, etc.)
+ */
+async function onNaturalBreak(activity = '') {
+  return check(TRIGGERS.NATURAL_BREAK, { activity });
+}
+
+/**
+ * Explicit check (user requested)
+ */
+async function checkNow() {
+  return check(TRIGGERS.EXPLICIT);
+}
+
+/**
+ * Get check stats
+ */
+function getStats() {
+  const state = loadState();
+  const now = Date.now();
+
+  return {
+    lastCheck: state.lastCheck ? new Date(state.lastCheck).toISOString() : null,
+    lastTrigger: state.lastTrigger,
+    checkCount: state.checkCount,
+    todayTriggers: state.triggersToday?.counts || {},
+    timeSinceLastCheck: state.lastCheck ? Math.floor((now - state.lastCheck) / 1000) : null,
+  };
+}
+
+module.exports = {
+  TRIGGERS,
+  check,
+  afterCommit,
+  afterTest,
+  afterBuild,
+  onNaturalBreak,
+  checkNow,
+  getStats,
+  shouldCheck,
+};