@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/agents/memory-engineers/redis-memory-engineer.js

@@ -0,0 +1,383 @@
+/**
+ * Redis Memory Engineer
+ *
+ * Fast cache layer for Boss Claude memory system.
+ * Queries Redis for recent sessions with <100ms response time.
+ *
+ * Features:
+ * - Query cache (boss:memory:query:{hash})
+ * - Recent sessions (boss:memory:recent:sessions)
+ * - Session summaries for text search
+ * - <100ms response time
+ *
+ * Architecture:
+ * - Layer 1: Query cache (instant hits)
+ * - Layer 2: Recent sessions (last 10 sessions, Redis sorted set)
+ * - Layer 3: Session summaries (full-text search on Redis)
+ *
+ * @module lib/agents/memory-engineers/redis-memory-engineer
+ */
+
+import Redis from 'ioredis';
+import crypto from 'crypto';
+import dotenv from 'dotenv';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+
+// Load environment variables
+const envPath = join(os.homedir(), '.boss-claude', '.env');
+if (existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+
+let redis = null;
+
+/**
+ * Get or create Redis client
+ */
+function getRedis() {
+  if (!redis) {
+    if (!process.env.REDIS_URL) {
+      throw new Error('REDIS_URL not found. Please run: boss-claude init');
+    }
+    redis = new Redis(process.env.REDIS_URL);
+  }
+  return redis;
+}
+
+/**
+ * Generate cache key hash for query
+ */
+function getCacheHash(query, filters = {}) {
+  const cacheKey = JSON.stringify({ query, filters });
+  return crypto.createHash('sha256').update(cacheKey).digest('hex').substring(0, 16);
+}
+
+/**
+ * Redis Memory Engineer Class
+ */
+export class RedisMemoryEngineer {
+  constructor() {
+    this.client = getRedis();
+    this.cachePrefix = 'boss:memory:query';
+    this.recentSessionsKey = 'boss:memory:recent:sessions';
+    this.sessionPrefix = 'boss:memory:session';
+    this.cacheTTL = 3600; // 1 hour cache TTL
+    this.maxRecentSessions = 10;
+  }
+
+  /**
+   * Query memory with caching
+   *
+   * @param {string} query - Search query
+   * @param {Object} filters - Optional filters (repo, tags, dateRange)
+   * @param {number} limit - Maximum results to return
+   * @returns {Promise<Array>} - Array of matching sessions
+   */
+  async query(query, filters = {}, limit = 5) {
+    const startTime = Date.now();
+
+    // Step 1: Check query cache
+    const cacheHash = getCacheHash(query, filters);
+    const cacheKey = `${this.cachePrefix}:${cacheHash}`;
+
+    const cached = await this.client.get(cacheKey);
+    if (cached) {
+      const results = JSON.parse(cached);
+      const duration = Date.now() - startTime;
+      return {
+        results: results.slice(0, limit),
+        source: 'cache',
+        duration_ms: duration
+      };
+    }
+
+    // Step 2: Search recent sessions
+    const results = await this.searchRecentSessions(query, filters, limit);
+
+    // Step 3: Cache results
+    await this.client.setex(cacheKey, this.cacheTTL, JSON.stringify(results));
+
+    const duration = Date.now() - startTime;
+    return {
+      results,
+      source: 'redis',
+      duration_ms: duration
+    };
+  }
+
+  /**
+   * Search recent sessions in Redis
+   */
+  async searchRecentSessions(query, filters = {}, limit = 5) {
+    // Get recent session IDs from sorted set
+    const sessionIds = await this.client.zrevrange(
+      this.recentSessionsKey,
+      0,
+      this.maxRecentSessions - 1
+    );
+
+    if (sessionIds.length === 0) {
+      return [];
+    }
+
+    // Fetch session data
+    const pipeline = this.client.pipeline();
+    sessionIds.forEach(id => {
+      pipeline.get(`${this.sessionPrefix}:${id}`);
+    });
+    const sessionData = await pipeline.exec();
+
+    // Parse and filter sessions
+    const sessions = sessionData
+      .map(([err, data]) => {
+        if (err || !data) return null;
+        try {
+          return JSON.parse(data);
+        } catch (e) {
+          return null;
+        }
+      })
+      .filter(s => s !== null);
+
+    // Apply filters and search
+    let filtered = sessions;
+
+    // Filter by repository
+    if (filters.repo) {
+      filtered = filtered.filter(s =>
+        s.repo && s.repo.name === filters.repo
+      );
+    }
+
+    // Filter by tags
+    if (filters.tags && filters.tags.length > 0) {
+      filtered = filtered.filter(s =>
+        s.tags && s.tags.some(tag => filters.tags.includes(tag))
+      );
+    }
+
+    // Filter by date range
+    if (filters.dateRange) {
+      const { start, end } = filters.dateRange;
+      filtered = filtered.filter(s => {
+        const sessionDate = new Date(s.started_at);
+        return (!start || sessionDate >= new Date(start)) &&
+               (!end || sessionDate <= new Date(end));
+      });
+    }
+
+    // Text search in summary and content
+    if (query) {
+      const queryLower = query.toLowerCase();
+      filtered = filtered.filter(s => {
+        const summaryMatch = s.summary && s.summary.toLowerCase().includes(queryLower);
+        const contentMatch = s.content && JSON.stringify(s.content).toLowerCase().includes(queryLower);
+        const tagsMatch = s.tags && s.tags.some(tag => tag.toLowerCase().includes(queryLower));
+        return summaryMatch || contentMatch || tagsMatch;
+      });
+    }
+
+    // Sort by relevance (date for now, could add scoring)
+    filtered.sort((a, b) =>
+      new Date(b.started_at) - new Date(a.started_at)
+    );
+
+    return filtered.slice(0, limit);
+  }
+
+  /**
+   * Add session to recent sessions cache
+   */
+  async addSession(sessionId, sessionData) {
+    const timestamp = Date.now();
+
+    // Add to sorted set (score = timestamp)
+    await this.client.zadd(
+      this.recentSessionsKey,
+      timestamp,
+      sessionId
+    );
+
+    // Store session data
+    await this.client.setex(
+      `${this.sessionPrefix}:${sessionId}`,
+      86400 * 7, // 7 days TTL
+      JSON.stringify(sessionData)
+    );
+
+    // Trim sorted set to max size
+    await this.client.zremrangebyrank(
+      this.recentSessionsKey,
+      0,
+      -(this.maxRecentSessions + 1)
+    );
+
+    return {
+      session_id: sessionId,
+      timestamp,
+      cached: true
+    };
+  }
+
+  /**
+   * Get recent sessions (no search)
+   */
+  async getRecentSessions(limit = 10) {
+    const startTime = Date.now();
+
+    const sessionIds = await this.client.zrevrange(
+      this.recentSessionsKey,
+      0,
+      limit - 1
+    );
+
+    if (sessionIds.length === 0) {
+      return {
+        results: [],
+        source: 'redis',
+        duration_ms: Date.now() - startTime
+      };
+    }
+
+    const pipeline = this.client.pipeline();
+    sessionIds.forEach(id => {
+      pipeline.get(`${this.sessionPrefix}:${id}`);
+    });
+    const sessionData = await pipeline.exec();
+
+    const sessions = sessionData
+      .map(([err, data]) => {
+        if (err || !data) return null;
+        try {
+          return JSON.parse(data);
+        } catch (e) {
+          return null;
+        }
+      })
+      .filter(s => s !== null);
+
+    return {
+      results: sessions,
+      source: 'redis',
+      duration_ms: Date.now() - startTime
+    };
+  }
+
+  /**
+   * Clear query cache
+   */
+  async clearCache(pattern = '*') {
+    const keys = [];
+    const matchPattern = `${this.cachePrefix}:${pattern}`;
+    let cursor = '0';
+
+    // Use SCAN instead of KEYS to avoid blocking Redis
+    do {
+      const [nextCursor, foundKeys] = await this.client.scan(
+        cursor,
+        'MATCH',
+        matchPattern,
+        'COUNT',
+        100
+      );
+      cursor = nextCursor;
+      keys.push(...foundKeys);
+    } while (cursor !== '0');
+
+    if (keys.length > 0) {
+      await this.client.del(...keys);
+    }
+    return {
+      cleared: keys.length,
+      pattern: matchPattern
+    };
+  }
+
+  /**
+   * Get cache stats
+   */
+  async getStats() {
+    const recentCount = await this.client.zcard(this.recentSessionsKey);
+
+    // Use SCAN instead of KEYS to avoid blocking Redis
+    const cacheKeys = [];
+    let cursor = '0';
+    do {
+      const [nextCursor, foundKeys] = await this.client.scan(
+        cursor,
+        'MATCH',
+        `${this.cachePrefix}:*`,
+        'COUNT',
+        100
+      );
+      cursor = nextCursor;
+      cacheKeys.push(...foundKeys);
+    } while (cursor !== '0');
+
+    const sessionKeys = [];
+    cursor = '0';
+    do {
+      const [nextCursor, foundKeys] = await this.client.scan(
+        cursor,
+        'MATCH',
+        `${this.sessionPrefix}:*`,
+        'COUNT',
+        100
+      );
+      cursor = nextCursor;
+      sessionKeys.push(...foundKeys);
+    } while (cursor !== '0');
+
+    return {
+      recent_sessions: recentCount,
+      cached_queries: cacheKeys.length,
+      stored_sessions: sessionKeys.length,
+      cache_prefix: this.cachePrefix,
+      session_prefix: this.sessionPrefix
+    };
+  }
+
+  /**
+   * Close Redis connection
+   */
+  async close() {
+    if (this.client) {
+      await this.client.quit();
+    }
+  }
+}
+
+/**
+ * Create and export singleton instance
+ */
+export const redisMemoryEngineer = new RedisMemoryEngineer();
+
+/**
+ * Quick query interface
+ */
+export async function queryMemory(query, filters = {}, limit = 5) {
+  return await redisMemoryEngineer.query(query, filters, limit);
+}
+
+/**
+ * Get recent sessions
+ */
+export async function getRecentSessions(limit = 10) {
+  return await redisMemoryEngineer.getRecentSessions(limit);
+}
+
+/**
+ * Add session to cache
+ */
+export async function cacheSession(sessionId, sessionData) {
+  return await redisMemoryEngineer.addSession(sessionId, sessionData);
+}
+
+/**
+ * Get cache statistics
+ */
+export async function getCacheStats() {
+  return await redisMemoryEngineer.getStats();
+}