squish-memory 1.0.2 → 1.2.0

package/core/storage/cache.ts

@@ -0,0 +1,241 @@
+import { config } from '../../config.js';
+import { logger } from '../logger.js';
+
+let redis: any = null;
+
+// LRU Cache with configurable size limits and TTL
+interface CacheEntry<T> {
+  value: T;
+  expires: number;
+  lastAccessed: number;
+}
+
+class LRUCache {
+  private cache = new Map<string, CacheEntry<unknown>>();
+  private maxSize: number;
+  private maxSizeBytes: number;
+  private currentSizeBytes: number = 0;
+  private cleanupTimer: NodeJS.Timeout | null = null;
+
+  constructor(maxSize: number = 1000, maxSizeBytes: number = 50 * 1024 * 1024) {
+    this.maxSize = maxSize;
+    this.maxSizeBytes = maxSizeBytes; // 50MB default
+    this.startCleanupTimer();
+  }
+
+  get<T>(key: string): T | null {
+    const entry = this.cache.get(key);
+
+    if (!entry) return null;
+
+    // Check expiration
+    if (entry.expires < Date.now()) {
+      this.delete(key);
+      return null;
+    }
+
+    // Update LRU access time
+    entry.lastAccessed = Date.now();
+
+    return entry.value as T;
+  }
+
+  set<T>(key: string, value: T, ttlMs: number = 3600000): void {
+    const size = this.estimateSize(value);
+
+    // Evict if needed
+    while (
+      (this.cache.size >= this.maxSize || this.currentSizeBytes + size > this.maxSizeBytes) &&
+      this.cache.size > 0
+    ) {
+      this.evictLRU();
+    }
+
+    // Delete old entry if exists
+    if (this.cache.has(key)) {
+      this.delete(key);
+    }
+
+    // Add new entry
+    this.cache.set(key, {
+      value,
+      expires: Date.now() + ttlMs,
+      lastAccessed: Date.now(),
+    });
+
+    this.currentSizeBytes += size;
+  }
+
+  delete(key: string): boolean {
+    const entry = this.cache.get(key);
+    if (entry) {
+      const size = this.estimateSize(entry.value);
+      this.currentSizeBytes = Math.max(0, this.currentSizeBytes - size);
+    }
+    return this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+    this.currentSizeBytes = 0;
+  }
+
+  size(): number {
+    return this.cache.size;
+  }
+
+  sizeBytes(): number {
+    return this.currentSizeBytes;
+  }
+
+  private evictLRU(): void {
+    let oldestKey: string | null = null;
+    let oldestTime = Infinity;
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.lastAccessed < oldestTime) {
+        oldestTime = entry.lastAccessed;
+        oldestKey = key;
+      }
+    }
+
+    if (oldestKey) {
+      logger.debug('Evicting LRU cache entry', { key: oldestKey });
+      this.delete(oldestKey);
+    }
+  }
+
+  private estimateSize(value: unknown): number {
+    try {
+      return JSON.stringify(value).length * 2; // UTF-16, rough estimate
+    } catch {
+      return 1024; // Default 1KB for non-serializable objects
+    }
+  }
+
+  private cleanup(): void {
+    const now = Date.now();
+    const toDelete: string[] = [];
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.expires < now) {
+        toDelete.push(key);
+      }
+    }
+
+    for (const key of toDelete) {
+      this.delete(key);
+    }
+
+    if (toDelete.length > 0) {
+      logger.debug('Cache cleanup removed expired entries', { count: toDelete.length });
+    }
+  }
+
+  private startCleanupTimer(): void {
+    // Cleanup every 5 minutes
+    this.cleanupTimer = setInterval(() => this.cleanup(), 5 * 60 * 1000);
+
+    // Prevent timer from keeping process alive
+    if (this.cleanupTimer.unref) {
+      this.cleanupTimer.unref();
+    }
+  }
+
+  stopCleanupTimer(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  getStats() {
+    return {
+      entries: this.cache.size,
+      sizeBytes: this.currentSizeBytes,
+      maxSize: this.maxSize,
+      maxSizeBytes: this.maxSizeBytes,
+      utilizationPercent: (this.cache.size / this.maxSize) * 100,
+      memoryUtilizationPercent: (this.currentSizeBytes / this.maxSizeBytes) * 100,
+    };
+  }
+}
+
+// Create LRU cache with configurable limits
+const memoryCache = new LRUCache(
+  parseInt(process.env.SQUISH_CACHE_MAX_ENTRIES || '1000'),
+  parseInt(process.env.SQUISH_CACHE_MAX_BYTES || '52428800') // 50MB
+);
+
+async function initRedis() {
+  if (!config.redisEnabled) return null;
+  if (redis) return redis;
+
+  try {
+    const { createClient } = await import('redis');
+    redis = createClient({ url: process.env.REDIS_URL });
+    await redis.connect();
+    logger.info('Redis connected');
+    return redis;
+  } catch (error) {
+    logger.error('Failed to connect to Redis, using memory cache', error);
+    redis = null;
+    return null;
+  }
+}
+
+export async function cacheGet<T>(key: string): Promise<T | null> {
+  try {
+    const r = await initRedis();
+    if (r) {
+      const value = await r.get(key);
+      return value ? (JSON.parse(value) as T) : null;
+    }
+  } catch (error) {
+    logger.error('Redis GET failed, falling back to memory', error);
+  }
+
+  // Memory cache fallback with LRU
+  return memoryCache.get<T>(key);
+}
+
+export async function cacheSet<T>(key: string, value: T, ttlMs: number = 3600000): Promise<void> {
+  try {
+    const r = await initRedis();
+    if (r) {
+      await r.setEx(key, Math.floor(ttlMs / 1000), JSON.stringify(value));
+      return;
+    }
+  } catch (error) {
+    logger.error('Redis SET failed, falling back to memory', error);
+  }
+
+  // Memory cache fallback with LRU
+  memoryCache.set(key, value, ttlMs);
+}
+
+export function getCacheStats() {
+  return memoryCache.getStats();
+}
+
+export async function closeCache(): Promise<void> {
+  if (redis) {
+    await redis.quit();
+    redis = null;
+  }
+  memoryCache.stopCleanupTimer();
+  memoryCache.clear();
+}
+
+export async function checkRedisHealth(): Promise<boolean> {
+  if (!config.redisEnabled) return true;
+  try {
+    const r = await initRedis();
+    if (!r) return false;
+    const pong = await r.ping();
+    return pong === 'PONG';
+  } catch (error) {
+    logger.error('Redis health check failed', error);
+    return false;
+  }
+}

package/core/storage/database.ts

@@ -0,0 +1,23 @@
+import type { Database } from 'better-sqlite3';
+import type { Pool } from 'pg';
+
+export interface DatabaseClient {
+  $client: Database | Pool;
+  $clientType: 'sqlite' | 'postgres';
+  select: (...args: any[]) => any;
+  insert: (...args: any[]) => any;
+  update: (...args: any[]) => any;
+  delete: (...args: any[]) => any;
+}
+
+export function createDatabaseClient(db: any): DatabaseClient {
+  const isSqlite = typeof (db.$client as any).prepare === 'function';
+  return {
+    $client: db.$client,
+    $clientType: isSqlite ? 'sqlite' : 'postgres',
+    select: (...args: any[]) => db.select(...args),
+    insert: (...args: any[]) => db.insert(...args),
+    update: (...args: any[]) => db.update(...args),
+    delete: (...args: any[]) => db.delete(...args),
+  };
+}

package/core/summarization/cleanup.ts

@@ -0,0 +1,13 @@
+/**
+ * Summarization Cleanup Operations
+ * Maintenance and cleanup for summarization data
+ */
+
+import { cleanupOldSessionSummaries } from '../utils/cleanup-operations.js';
+
+/**
+ * Delete old summaries to save space
+ */
+export async function pruneOldSummaries(olderThanDays: number = 30): Promise<number> {
+  return cleanupOldSessionSummaries(olderThanDays);
+}

package/core/summarization/queries.ts

@@ -0,0 +1,32 @@
+/**
+ * Summarization Queries
+ * Database operations for summary retrieval
+ */
+
+import { eq, desc } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+
+/**
+ * Get recent summaries for a conversation
+ */
+export async function getRecentSummaries(
+  conversationId: string,
+  limit: number = 10
+): Promise<any[]> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    return await (db as any)
+      .select()
+      .from(schema.sessionSummaries)
+      .where(eq(schema.sessionSummaries.conversationId, conversationId))
+      .orderBy(desc(schema.sessionSummaries.createdAt))
+      .limit(limit);
+  } catch (error) {
+    logger.error('Error getting recent summaries', error);
+    return [];
+  }
+}

package/core/summarization/stats.ts

@@ -0,0 +1,64 @@
+/**
+ * Summarization Statistics
+ * Analytics and statistics for summarization operations
+ */
+
+import { eq } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+
+/**
+ * Get summarization statistics
+ */
+export async function getSummarizationStats(projectId?: string): Promise<{
+  totalSummaries: number;
+  byType: Record<string, number>;
+  totalTokensSaved: number;
+  avgCompressionRatio: number;
+}> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    const where = projectId ? eq(schema.sessionSummaries.projectId, projectId) : undefined;
+
+    const summaries = await (db as any).select().from(schema.sessionSummaries).where(where);
+
+    const stats = {
+      totalSummaries: summaries.length,
+      byType: {
+        incremental: 0,
+        rolling: 0,
+        final: 0,
+      } as Record<string, number>,
+      totalTokensSaved: 0,
+      avgCompressionRatio: 0,
+    };
+
+    for (const s of summaries) {
+      stats.byType[s.summaryType] = (stats.byType[s.summaryType] || 0) + 1;
+      stats.totalTokensSaved += s.tokensSaved || 0;
+    }
+
+    // Calculate average compression ratio
+    let totalRatio = 0;
+    for (const s of summaries) {
+      if (s.compressedFrom && s.compressedFrom > 0) {
+        totalRatio += s.tokensSaved / (s.compressedFrom * 100); // Rough estimate
+      }
+    }
+
+    stats.avgCompressionRatio = summaries.length > 0 ? totalRatio / summaries.length : 0;
+
+    return stats;
+  } catch (error) {
+    logger.error('Error getting summarization stats', error);
+    return {
+      totalSummaries: 0,
+      byType: {},
+      totalTokensSaved: 0,
+      avgCompressionRatio: 0,
+    };
+  }
+}

package/core/summarization/strategies.ts

@@ -0,0 +1,52 @@
+/**
+ * Summarization Strategies
+ * Implements different summarization algorithms
+ */
+
+import {
+  chunkMessages,
+  getRollingWindow,
+} from '../utils/summarization-helpers.js';
+import { extractMessageContent, generateExtractiveSummary } from '../utils/content-extraction.js';
+
+export type SummaryType = 'incremental' | 'rolling' | 'final';
+
+export interface SummarizationConfig {
+  incrementalThreshold: number; // Summarize every N messages
+  rollingWindowSize: number; // Rolling summary window
+  compressionRatio: number; // Target compression ratio
+  enabled: boolean;
+}
+
+/**
+ * Create incremental summary (summary in chunks)
+ */
+export async function createIncrementalSummary(
+  messages: any[],
+  config: SummarizationConfig
+): Promise<string> {
+  const chunks = chunkMessages(messages, config.incrementalThreshold);
+  const summaries = chunks.map(chunk => generateExtractiveSummary(extractMessageContent(chunk)));
+  return summaries.join('\n---\n');
+}
+
+/**
+ * Create rolling summary (last N messages)
+ */
+export async function createRollingSummary(
+  messages: any[],
+  config: SummarizationConfig
+): Promise<string> {
+  const window = getRollingWindow(messages, config.rollingWindowSize);
+  return generateExtractiveSummary(extractMessageContent(window));
+}
+
+/**
+ * Create final summary (entire conversation)
+ */
+export async function createFinalSummary(
+  messages: any[],
+  config: SummarizationConfig
+): Promise<string> {
+  return generateExtractiveSummary(extractMessageContent(messages));
+}

package/core/summarization.ts

@@ -0,0 +1,248 @@
+/**
+ * Aggressive Session Summarization
+ * Implements incremental, rolling, and final summarization
+ */
+
+import { eq, and, gte, desc } from 'drizzle-orm';
+import { randomUUID } from 'crypto';
+import { getDb } from '../db/index.js';
+import { getSchema } from '../db/schema.js';
+import { config } from '../config.js';
+import { getEmbedding } from './embeddings.js';
+import { cleanupOldSessionSummaries } from './utils/cleanup-operations.js';
+import {
+  chunkMessages,
+  getRollingWindow,
+  calculateTokensSaved,
+  estimateTokens
+} from './utils/summarization-helpers.js';
+import { extractMessageContent, generateExtractiveSummary } from './utils/content-extraction.js';
+import { logger } from './logger.js';
+
+export type SummaryType = 'incremental' | 'rolling' | 'final';
+
+export interface SummarizationConfig {
+  incrementalThreshold: number; // Summarize every N messages
+  rollingWindowSize: number; // Rolling summary window
+  compressionRatio: number; // Target compression ratio
+  enabled: boolean;
+}
+
+const DEFAULT_CONFIG: SummarizationConfig = {
+  incrementalThreshold: config.incrementalThreshold || 10,
+  rollingWindowSize: 50,
+  compressionRatio: 0.2, // 5:1 compression
+  enabled: config.summarizationEnabled !== false,
+};
+
+/**
+ * Summarize a conversation session
+ */
+export async function summarizeSession(
+  conversationId: string,
+  summaryType: SummaryType,
+  customConfig: Partial<SummarizationConfig> = {}
+): Promise<{ summaryId: string; tokensSaved: number; summary: string }> {
+  const finalConfig = { ...DEFAULT_CONFIG, ...customConfig };
+
+  if (!finalConfig.enabled) {
+    return { summaryId: '', tokensSaved: 0, summary: '' };
+  }
+
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    // Fetch messages for this conversation
+    const messages = await (db as any)
+      .select()
+      .from(schema.messages)
+      .where(eq(schema.messages.conversationId, conversationId))
+      .orderBy(schema.messages.createdAt);
+
+    if (messages.length === 0) {
+      return { summaryId: '', tokensSaved: 0, summary: '' };
+    }
+
+    let summary = '';
+
+    switch (summaryType) {
+      case 'incremental':
+        summary = await createIncrementalSummary(messages, finalConfig);
+        break;
+      case 'rolling':
+        summary = await createRollingSummary(messages, finalConfig);
+        break;
+      case 'final':
+        summary = await createFinalSummary(messages, finalConfig);
+        break;
+    }
+
+    if (summary) {
+      // Store summary with embedding
+      const embedding = await getEmbedding(summary);
+      const conversation = await (db as any)
+        .select()
+        .from(schema.conversations)
+        .where(eq(schema.conversations.id, conversationId))
+        .limit(1);
+
+      if (conversation.length > 0) {
+        const tokensSaved = estimateTokensSaved(messages, summary);
+        const summaryId = randomUUID();
+
+        await (db as any).insert(schema.sessionSummaries).values({
+          id: summaryId,
+          conversationId,
+          projectId: conversation[0].projectId,
+          summaryType,
+          content: summary,
+          compressedFrom: messages.length,
+          tokensSaved,
+          embedding: embedding || null,
+          createdAt: new Date(),
+        });
+
+        return { summaryId, tokensSaved, summary };
+      }
+    }
+
+    return { summaryId: '', tokensSaved: 0, summary };
+  } catch (error) {
+    logger.error('Error summarizing session', error);
+    return { summaryId: '', tokensSaved: 0, summary: '' };
+  }
+}
+
+/**
+ * Create incremental summary (summary in chunks)
+ */
+async function createIncrementalSummary(
+  messages: any[],
+  config: SummarizationConfig
+): Promise<string> {
+  const chunks = chunkMessages(messages, config.incrementalThreshold);
+  const summaries = chunks.map(chunk => generateExtractiveSummary(extractMessageContent(chunk)));
+  return summaries.join('\n---\n');
+}
+
+/**
+ * Create rolling summary (last N messages)
+ */
+async function createRollingSummary(
+  messages: any[],
+  config: SummarizationConfig
+): Promise<string> {
+  const window = getRollingWindow(messages, config.rollingWindowSize);
+  return generateExtractiveSummary(extractMessageContent(window));
+}
+
+/**
+ * Create final summary (entire conversation)
+ */
+async function createFinalSummary(
+  messages: any[],
+  config: SummarizationConfig
+): Promise<string> {
+  return generateExtractiveSummary(extractMessageContent(messages));
+}
+
+/**
+ * Generate basic extractive summary of messages
+ */
+function summarizeChunk(messages: any[]): string {
+  if (messages.length === 0) return '';
+  return generateExtractiveSummary(extractMessageContent(messages));
+}
+
+/**
+ * Estimate tokens saved by summarization
+ */
+function estimateTokensSaved(messages: any[], summary: string): number {
+  return calculateTokensSaved(messages, summary);
+}
+
+/**
+ * Get recent summaries for a conversation
+ */
+export async function getRecentSummaries(
+  conversationId: string,
+  limit: number = 10
+): Promise<any[]> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    return await (db as any)
+      .select()
+      .from(schema.sessionSummaries)
+      .where(eq(schema.sessionSummaries.conversationId, conversationId))
+      .orderBy(desc(schema.sessionSummaries.createdAt))
+      .limit(limit);
+  } catch (error) {
+    logger.error('Error getting recent summaries', error);
+    return [];
+  }
+}
+
+/**
+ * Get summarization statistics
+ */
+export async function getSummarizationStats(projectId?: string): Promise<{
+  totalSummaries: number;
+  byType: Record<string, number>;
+  totalTokensSaved: number;
+  avgCompressionRatio: number;
+}> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    const where = projectId ? eq(schema.sessionSummaries.projectId, projectId) : undefined;
+
+    const summaries = await (db as any).select().from(schema.sessionSummaries).where(where);
+
+    const stats = {
+      totalSummaries: summaries.length,
+      byType: {
+        incremental: 0,
+        rolling: 0,
+        final: 0,
+      } as Record<string, number>,
+      totalTokensSaved: 0,
+      avgCompressionRatio: 0,
+    };
+
+    for (const s of summaries) {
+      stats.byType[s.summaryType] = (stats.byType[s.summaryType] || 0) + 1;
+      stats.totalTokensSaved += s.tokensSaved || 0;
+    }
+
+    // Calculate average compression ratio
+    let totalRatio = 0;
+    for (const s of summaries) {
+      if (s.compressedFrom && s.compressedFrom > 0) {
+        totalRatio += s.tokensSaved / (s.compressedFrom * 100); // Rough estimate
+      }
+    }
+
+    stats.avgCompressionRatio = summaries.length > 0 ? totalRatio / summaries.length : 0;
+
+    return stats;
+  } catch (error) {
+    logger.error('Error getting summarization stats', error);
+    return {
+      totalSummaries: 0,
+      byType: {},
+      totalTokensSaved: 0,
+      avgCompressionRatio: 0,
+    };
+  }
+}
+
+/**
+ * Delete old summaries to save space
+ */
+export async function pruneOldSummaries(olderThanDays: number = 30): Promise<number> {
+  return cleanupOldSessionSummaries(olderThanDays);
+}