slashvibe-mcp 0.2.2 → 0.2.3

package/intelligence/patterns.js

@@ -0,0 +1,651 @@
+/**
+ * Work Patterns — Ambient behavioral memory
+ *
+ * Quietly observes and remembers:
+ * - Session timing (when you work, how long)
+ * - State patterns (how often in each state)
+ * - Module affinity (where you spend time)
+ *
+ * Stored locally in ~/.vibe/work-patterns.json
+ * Never transmitted. Private by default.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PATTERNS_FILE = path.join(process.env.HOME, '.vibe', 'work-patterns.json');
+
+// Ensure directory exists
+function ensureDir() {
+  const dir = path.dirname(PATTERNS_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// Load patterns from disk
+function load() {
+  try {
+    if (fs.existsSync(PATTERNS_FILE)) {
+      return JSON.parse(fs.readFileSync(PATTERNS_FILE, 'utf8'));
+    }
+  } catch (e) {
+    console.error('[patterns] Load error:', e.message);
+  }
+  return createEmpty();
+}
+
+// Save patterns to disk
+function save(patterns) {
+  ensureDir();
+  try {
+    fs.writeFileSync(PATTERNS_FILE, JSON.stringify(patterns, null, 2));
+  } catch (e) {
+    console.error('[patterns] Save error:', e.message);
+  }
+}
+
+// Create empty patterns structure
+function createEmpty() {
+  return {
+    version: 2,
+    firstSeen: new Date().toISOString(),
+    lastUpdated: new Date().toISOString(),
+
+    // === WORK PATTERNS ===
+    sessions: {
+      total: 0,
+      totalMinutes: 0,
+      byHour: Array(24).fill(0),      // Activity by hour of day
+      byDay: Array(7).fill(0),         // Activity by day of week (0=Sun)
+      longestMinutes: 0,
+      averageMinutes: 0
+    },
+
+    states: {
+      // state -> { count, totalMinutes }
+    },
+
+    modules: {
+      // module -> { visits, totalMinutes }
+    },
+
+    recentSessions: [],
+
+    // === SOCIAL PATTERNS ===
+    social: {
+      // handle -> { messages, lastContact, topics: [] }
+      connections: {},
+      // Total interaction counts
+      messagesSent: 0,
+      messagesReceived: 0,
+      reactionsGiven: 0,
+      reactionsReceived: 0,
+      // Who they interact with most
+      topConnections: []
+    },
+
+    // === CREATIVE PATTERNS ===
+    creative: {
+      // What they've shipped
+      ships: [],
+      // Ideas they've posted
+      ideas: [],
+      // Ideas they've riffed on
+      riffs: [],
+      // Domains they explore
+      domains: {},
+      // Attribution given/received
+      inspired: [],      // who inspired them
+      inspiredOthers: [] // who they've inspired
+    }
+  };
+}
+
+// ============ EVENT LOGGING ============
+
+/**
+ * Log session start
+ */
+function logSessionStart(handle) {
+  const patterns = load();
+  const now = new Date();
+
+  patterns.sessions.total++;
+  patterns.sessions.byHour[now.getHours()]++;
+  patterns.sessions.byDay[now.getDay()]++;
+
+  // Track current session
+  patterns._currentSession = {
+    start: now.toISOString(),
+    handle,
+    states: [],
+    modules: []
+  };
+
+  patterns.lastUpdated = now.toISOString();
+  save(patterns);
+}
+
+/**
+ * Log session end
+ */
+function logSessionEnd() {
+  const patterns = load();
+  if (!patterns._currentSession) return;
+
+  const now = new Date();
+  const start = new Date(patterns._currentSession.start);
+  const durationMinutes = Math.round((now - start) / 60000);
+
+  // Update totals
+  patterns.sessions.totalMinutes += durationMinutes;
+  patterns.sessions.averageMinutes = Math.round(
+    patterns.sessions.totalMinutes / patterns.sessions.total
+  );
+  if (durationMinutes > patterns.sessions.longestMinutes) {
+    patterns.sessions.longestMinutes = durationMinutes;
+  }
+
+  // Add to recent sessions
+  patterns.recentSessions.unshift({
+    date: patterns._currentSession.start,
+    durationMinutes,
+    states: patterns._currentSession.states,
+    modules: patterns._currentSession.modules
+  });
+
+  // Keep only last 20 sessions
+  if (patterns.recentSessions.length > 20) {
+    patterns.recentSessions = patterns.recentSessions.slice(0, 20);
+  }
+
+  delete patterns._currentSession;
+  patterns.lastUpdated = now.toISOString();
+  save(patterns);
+}
+
+/**
+ * Log state observation
+ */
+function logState(state, durationMinutes = 5) {
+  if (!state) return;
+
+  const patterns = load();
+
+  // Initialize state if new
+  if (!patterns.states[state]) {
+    patterns.states[state] = { count: 0, totalMinutes: 0 };
+  }
+
+  patterns.states[state].count++;
+  patterns.states[state].totalMinutes += durationMinutes;
+
+  // Track in current session
+  if (patterns._currentSession) {
+    if (!patterns._currentSession.states.includes(state)) {
+      patterns._currentSession.states.push(state);
+    }
+  }
+
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+/**
+ * Log module/file observation
+ */
+function logModule(filePath) {
+  if (!filePath) return;
+
+  const patterns = load();
+
+  // Extract module from path
+  const module = extractModule(filePath);
+  if (!module) return;
+
+  // Initialize module if new
+  if (!patterns.modules[module]) {
+    patterns.modules[module] = { visits: 0, totalMinutes: 0 };
+  }
+
+  patterns.modules[module].visits++;
+  patterns.modules[module].totalMinutes += 5; // Assume 5min per observation
+
+  // Track in current session
+  if (patterns._currentSession) {
+    if (!patterns._currentSession.modules.includes(module)) {
+      patterns._currentSession.modules.push(module);
+    }
+  }
+
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+// ============ SOCIAL LOGGING ============
+
+/**
+ * Log a message sent to someone
+ */
+function logMessageSent(toHandle, topic = null) {
+  if (!toHandle) return;
+
+  const patterns = load();
+  const handle = toHandle.replace('@', '').toLowerCase();
+
+  // Initialize connection if new
+  if (!patterns.social.connections[handle]) {
+    patterns.social.connections[handle] = {
+      messages: 0,
+      received: 0,
+      lastContact: null,
+      topics: []
+    };
+  }
+
+  patterns.social.connections[handle].messages++;
+  patterns.social.connections[handle].lastContact = new Date().toISOString();
+  patterns.social.messagesSent++;
+
+  // Track topic if provided
+  if (topic && !patterns.social.connections[handle].topics.includes(topic)) {
+    patterns.social.connections[handle].topics.push(topic);
+    // Keep topics list reasonable
+    if (patterns.social.connections[handle].topics.length > 10) {
+      patterns.social.connections[handle].topics.shift();
+    }
+  }
+
+  updateTopConnections(patterns);
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+/**
+ * Log a message received from someone
+ */
+function logMessageReceived(fromHandle) {
+  if (!fromHandle) return;
+
+  const patterns = load();
+  const handle = fromHandle.replace('@', '').toLowerCase();
+
+  if (!patterns.social.connections[handle]) {
+    patterns.social.connections[handle] = {
+      messages: 0,
+      received: 0,
+      lastContact: null,
+      topics: []
+    };
+  }
+
+  patterns.social.connections[handle].received++;
+  patterns.social.connections[handle].lastContact = new Date().toISOString();
+  patterns.social.messagesReceived++;
+
+  updateTopConnections(patterns);
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+/**
+ * Log a reaction given
+ */
+function logReaction(toHandle, reaction) {
+  if (!toHandle) return;
+
+  const patterns = load();
+  patterns.social.reactionsGiven++;
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+/**
+ * Update top connections list (internal)
+ */
+function updateTopConnections(patterns) {
+  const connections = Object.entries(patterns.social.connections);
+  connections.sort((a, b) => {
+    const aTotal = a[1].messages + a[1].received;
+    const bTotal = b[1].messages + b[1].received;
+    return bTotal - aTotal;
+  });
+
+  patterns.social.topConnections = connections
+    .slice(0, 5)
+    .map(([handle, data]) => ({
+      handle,
+      total: data.messages + data.received,
+      lastContact: data.lastContact
+    }));
+}
+
+// ============ CREATIVE LOGGING ============
+
+/**
+ * Log something shipped
+ */
+function logShip(what, url = null, tags = []) {
+  const patterns = load();
+
+  patterns.creative.ships.unshift({
+    what,
+    url,
+    tags,
+    timestamp: new Date().toISOString()
+  });
+
+  // Keep last 20 ships
+  if (patterns.creative.ships.length > 20) {
+    patterns.creative.ships = patterns.creative.ships.slice(0, 20);
+  }
+
+  // Track domains from tags
+  tags.forEach(tag => {
+    if (!patterns.creative.domains[tag]) {
+      patterns.creative.domains[tag] = 0;
+    }
+    patterns.creative.domains[tag]++;
+  });
+
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+/**
+ * Log an idea posted
+ */
+function logIdea(content, tags = []) {
+  const patterns = load();
+
+  patterns.creative.ideas.unshift({
+    content: content.substring(0, 100),
+    tags,
+    timestamp: new Date().toISOString()
+  });
+
+  // Keep last 20
+  if (patterns.creative.ideas.length > 20) {
+    patterns.creative.ideas = patterns.creative.ideas.slice(0, 20);
+  }
+
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+/**
+ * Log a riff on someone's idea
+ */
+function logRiff(originalAuthor, content) {
+  const patterns = load();
+
+  patterns.creative.riffs.unshift({
+    on: originalAuthor.replace('@', '').toLowerCase(),
+    content: content.substring(0, 100),
+    timestamp: new Date().toISOString()
+  });
+
+  // Keep last 20
+  if (patterns.creative.riffs.length > 20) {
+    patterns.creative.riffs = patterns.creative.riffs.slice(0, 20);
+  }
+
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+/**
+ * Log attribution (inspired by someone)
+ */
+function logInspiredBy(handle) {
+  if (!handle) return;
+
+  const patterns = load();
+  const clean = handle.replace('@', '').toLowerCase();
+
+  // Track who inspires them
+  const existing = patterns.creative.inspired.find(i => i.handle === clean);
+  if (existing) {
+    existing.count++;
+    existing.lastTime = new Date().toISOString();
+  } else {
+    patterns.creative.inspired.push({
+      handle: clean,
+      count: 1,
+      lastTime: new Date().toISOString()
+    });
+  }
+
+  patterns.lastUpdated = new Date().toISOString();
+  save(patterns);
+}
+
+// ============ PATTERN QUERIES ============
+
+/**
+ * Get peak hours (when user is most active)
+ */
+function getPeakHours() {
+  const patterns = load();
+  const hours = patterns.sessions.byHour;
+
+  // Find top 3 hours
+  const indexed = hours.map((count, hour) => ({ hour, count }));
+  indexed.sort((a, b) => b.count - a.count);
+
+  return indexed.slice(0, 3).filter(h => h.count > 0);
+}
+
+/**
+ * Get dominant state (most common)
+ */
+function getDominantState() {
+  const patterns = load();
+  const states = Object.entries(patterns.states);
+
+  if (states.length === 0) return null;
+
+  states.sort((a, b) => b[1].totalMinutes - a[1].totalMinutes);
+  return {
+    state: states[0][0],
+    minutes: states[0][1].totalMinutes,
+    percentage: Math.round(
+      (states[0][1].totalMinutes / patterns.sessions.totalMinutes) * 100
+    )
+  };
+}
+
+/**
+ * Get top modules (where user spends most time)
+ */
+function getTopModules(limit = 3) {
+  const patterns = load();
+  const modules = Object.entries(patterns.modules);
+
+  if (modules.length === 0) return [];
+
+  modules.sort((a, b) => b[1].totalMinutes - a[1].totalMinutes);
+  return modules.slice(0, limit).map(([name, data]) => ({
+    name,
+    minutes: data.totalMinutes,
+    visits: data.visits
+  }));
+}
+
+/**
+ * Get session rhythm (typical session length, frequency)
+ */
+function getSessionRhythm() {
+  const patterns = load();
+
+  return {
+    totalSessions: patterns.sessions.total,
+    averageMinutes: patterns.sessions.averageMinutes,
+    longestMinutes: patterns.sessions.longestMinutes,
+    totalHours: Math.round(patterns.sessions.totalMinutes / 60)
+  };
+}
+
+/**
+ * Get full patterns summary (for debugging/display)
+ */
+function getSummary() {
+  const patterns = load();
+
+  return {
+    since: patterns.firstSeen,
+    sessions: getSessionRhythm(),
+    peakHours: getPeakHours(),
+    dominantState: getDominantState(),
+    topModules: getTopModules(),
+    recentSessions: patterns.recentSessions.slice(0, 5)
+  };
+}
+
+/**
+ * Check if we have enough data for insights
+ */
+function hasEnoughData() {
+  const patterns = load();
+  return patterns.sessions.total >= 3;
+}
+
+// ============ SOCIAL QUERIES ============
+
+/**
+ * Get top connections (people they interact with most)
+ */
+function getTopConnections(limit = 5) {
+  const patterns = load();
+  return patterns.social.topConnections.slice(0, limit);
+}
+
+/**
+ * Get connection details for a specific handle
+ */
+function getConnection(handle) {
+  const patterns = load();
+  const clean = handle.replace('@', '').toLowerCase();
+  return patterns.social.connections[clean] || null;
+}
+
+/**
+ * Get social summary
+ */
+function getSocialSummary() {
+  const patterns = load();
+  return {
+    messagesSent: patterns.social.messagesSent,
+    messagesReceived: patterns.social.messagesReceived,
+    reactionsGiven: patterns.social.reactionsGiven,
+    uniqueConnections: Object.keys(patterns.social.connections).length,
+    topConnections: patterns.social.topConnections
+  };
+}
+
+// ============ CREATIVE QUERIES ============
+
+/**
+ * Get recent ships
+ */
+function getRecentShips(limit = 5) {
+  const patterns = load();
+  return patterns.creative.ships.slice(0, limit);
+}
+
+/**
+ * Get top creative domains (what they build)
+ */
+function getTopDomains(limit = 5) {
+  const patterns = load();
+  const domains = Object.entries(patterns.creative.domains);
+  domains.sort((a, b) => b[1] - a[1]);
+  return domains.slice(0, limit).map(([domain, count]) => ({ domain, count }));
+}
+
+/**
+ * Get creative inspirations (who inspires them)
+ */
+function getInspirations(limit = 5) {
+  const patterns = load();
+  const inspired = [...patterns.creative.inspired];
+  inspired.sort((a, b) => b.count - a.count);
+  return inspired.slice(0, limit);
+}
+
+/**
+ * Get creative summary
+ */
+function getCreativeSummary() {
+  const patterns = load();
+  return {
+    totalShips: patterns.creative.ships.length,
+    totalIdeas: patterns.creative.ideas.length,
+    totalRiffs: patterns.creative.riffs.length,
+    topDomains: getTopDomains(3),
+    inspirations: getInspirations(3),
+    recentShips: patterns.creative.ships.slice(0, 3)
+  };
+}
+
+// ============ HELPERS ============
+
+function extractModule(filePath) {
+  if (!filePath) return null;
+
+  const parts = filePath.split('/');
+  const meaningful = ['src', 'lib', 'app', 'components', 'pages', 'api',
+                      'services', 'utils', 'hooks', 'store', 'models'];
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (meaningful.includes(parts[i])) {
+      return parts[i + 1] || parts[i];
+    }
+  }
+
+  // Default to parent directory
+  return parts.length >= 2 ? parts[parts.length - 2] : null;
+}
+
+module.exports = {
+  // Work logging
+  logSessionStart,
+  logSessionEnd,
+  logState,
+  logModule,
+
+  // Social logging
+  logMessageSent,
+  logMessageReceived,
+  logReaction,
+
+  // Creative logging
+  logShip,
+  logIdea,
+  logRiff,
+  logInspiredBy,
+
+  // Work queries
+  getPeakHours,
+  getDominantState,
+  getTopModules,
+  getSessionRhythm,
+  getSummary,
+  hasEnoughData,
+
+  // Social queries
+  getTopConnections,
+  getConnection,
+  getSocialSummary,
+
+  // Creative queries
+  getRecentShips,
+  getTopDomains,
+  getInspirations,
+  getCreativeSummary,
+
+  // Direct access
+  load,
+  save
+};