squish-memory 1.1.5 → 1.2.1

package/dist/core/storage/cache.js

@@ -1,202 +0,0 @@
-import { config } from '../../config.js';
-import { logger } from '../logger.js';
-let redis = null;
-class LRUCache {
-    cache = new Map();
-    maxSize;
-    maxSizeBytes;
-    currentSizeBytes = 0;
-    cleanupTimer = null;
-    constructor(maxSize = 1000, maxSizeBytes = 50 * 1024 * 1024) {
-        this.maxSize = maxSize;
-        this.maxSizeBytes = maxSizeBytes; // 50MB default
-        this.startCleanupTimer();
-    }
-    get(key) {
-        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;
-    }
-    set(key, value, ttlMs = 3600000) {
-        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) {
-        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() {
-        this.cache.clear();
-        this.currentSizeBytes = 0;
-    }
-    size() {
-        return this.cache.size;
-    }
-    sizeBytes() {
-        return this.currentSizeBytes;
-    }
-    evictLRU() {
-        let oldestKey = 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);
-        }
-    }
-    estimateSize(value) {
-        try {
-            return JSON.stringify(value).length * 2; // UTF-16, rough estimate
-        }
-        catch {
-            return 1024; // Default 1KB for non-serializable objects
-        }
-    }
-    cleanup() {
-        const now = Date.now();
-        const toDelete = [];
-        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 });
-        }
-    }
-    startCleanupTimer() {
-        // 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() {
-        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(key) {
-    try {
-        const r = await initRedis();
-        if (r) {
-            const value = await r.get(key);
-            return value ? JSON.parse(value) : null;
-        }
-    }
-    catch (error) {
-        logger.error('Redis GET failed, falling back to memory', error);
-    }
-    // Memory cache fallback with LRU
-    return memoryCache.get(key);
-}
-export async function cacheSet(key, value, ttlMs = 3600000) {
-    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() {
-    if (redis) {
-        await redis.quit();
-        redis = null;
-    }
-    memoryCache.stopCleanupTimer();
-    memoryCache.clear();
-}
-export async function checkRedisHealth() {
-    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;
-    }
-}
-//# sourceMappingURL=cache.js.map

package/dist/core/storage/database.d.ts

@@ -1,12 +0,0 @@
-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 declare function createDatabaseClient(db: any): DatabaseClient;
-//# sourceMappingURL=database.d.ts.map

package/dist/core/storage/database.js

@@ -1,12 +0,0 @@
-export function createDatabaseClient(db) {
-    const isSqlite = typeof db.$client.prepare === 'function';
-    return {
-        $client: db.$client,
-        $clientType: isSqlite ? 'sqlite' : 'postgres',
-        select: (...args) => db.select(...args),
-        insert: (...args) => db.insert(...args),
-        update: (...args) => db.update(...args),
-        delete: (...args) => db.delete(...args),
-    };
-}
-//# sourceMappingURL=database.js.map

package/dist/core/summarization/cleanup.d.ts

@@ -1,9 +0,0 @@
-/**
- * Summarization Cleanup Operations
- * Maintenance and cleanup for summarization data
- */
-/**
- * Delete old summaries to save space
- */
-export declare function pruneOldSummaries(olderThanDays?: number): Promise<number>;
-//# sourceMappingURL=cleanup.d.ts.map

package/dist/core/summarization/queries.d.ts

@@ -1,9 +0,0 @@
-/**
- * Summarization Queries
- * Database operations for summary retrieval
- */
-/**
- * Get recent summaries for a conversation
- */
-export declare function getRecentSummaries(conversationId: string, limit?: number): Promise<any[]>;
-//# sourceMappingURL=queries.d.ts.map

package/dist/core/summarization/queries.js

@@ -1,28 +0,0 @@
-/**
- * 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, limit = 10) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        return await db
-            .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 [];
-    }
-}
-//# sourceMappingURL=queries.js.map

package/dist/core/summarization/stats.d.ts

@@ -1,14 +0,0 @@
-/**
- * Summarization Statistics
- * Analytics and statistics for summarization operations
- */
-/**
- * Get summarization statistics
- */
-export declare function getSummarizationStats(projectId?: string): Promise<{
-    totalSummaries: number;
-    byType: Record<string, number>;
-    totalTokensSaved: number;
-    avgCompressionRatio: number;
-}>;
-//# sourceMappingURL=stats.d.ts.map

package/dist/core/summarization/stats.js

@@ -1,52 +0,0 @@
-/**
- * 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) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const where = projectId ? eq(schema.sessionSummaries.projectId, projectId) : undefined;
-        const summaries = await db.select().from(schema.sessionSummaries).where(where);
-        const stats = {
-            totalSummaries: summaries.length,
-            byType: {
-                incremental: 0,
-                rolling: 0,
-                final: 0,
-            },
-            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,
-        };
-    }
-}
-//# sourceMappingURL=stats.js.map

package/dist/core/summarization/strategies.d.ts

@@ -1,24 +0,0 @@
-/**
- * Summarization Strategies
- * Implements different summarization algorithms
- */
-export type SummaryType = 'incremental' | 'rolling' | 'final';
-export interface SummarizationConfig {
-    incrementalThreshold: number;
-    rollingWindowSize: number;
-    compressionRatio: number;
-    enabled: boolean;
-}
-/**
- * Create incremental summary (summary in chunks)
- */
-export declare function createIncrementalSummary(messages: any[], config: SummarizationConfig): Promise<string>;
-/**
- * Create rolling summary (last N messages)
- */
-export declare function createRollingSummary(messages: any[], config: SummarizationConfig): Promise<string>;
-/**
- * Create final summary (entire conversation)
- */
-export declare function createFinalSummary(messages: any[], config: SummarizationConfig): Promise<string>;
-//# sourceMappingURL=strategies.d.ts.map

package/dist/core/summarization/strategies.js

@@ -1,28 +0,0 @@
-/**
- * Summarization Strategies
- * Implements different summarization algorithms
- */
-import { chunkMessages, getRollingWindow, } from '../utils/summarization-helpers.js';
-import { extractMessageContent, generateExtractiveSummary } from '../utils/content-extraction.js';
-/**
- * Create incremental summary (summary in chunks)
- */
-export async function createIncrementalSummary(messages, config) {
-    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, config) {
-    const window = getRollingWindow(messages, config.rollingWindowSize);
-    return generateExtractiveSummary(extractMessageContent(window));
-}
-/**
- * Create final summary (entire conversation)
- */
-export async function createFinalSummary(messages, config) {
-    return generateExtractiveSummary(extractMessageContent(messages));
-}
-//# sourceMappingURL=strategies.js.map

package/dist/core/summarization.d.ts

@@ -1,37 +0,0 @@
-/**
- * Aggressive Session Summarization
- * Implements incremental, rolling, and final summarization
- */
-export type SummaryType = 'incremental' | 'rolling' | 'final';
-export interface SummarizationConfig {
-    incrementalThreshold: number;
-    rollingWindowSize: number;
-    compressionRatio: number;
-    enabled: boolean;
-}
-/**
- * Summarize a conversation session
- */
-export declare function summarizeSession(conversationId: string, summaryType: SummaryType, customConfig?: Partial<SummarizationConfig>): Promise<{
-    summaryId: string;
-    tokensSaved: number;
-    summary: string;
-}>;
-/**
- * Get recent summaries for a conversation
- */
-export declare function getRecentSummaries(conversationId: string, limit?: number): Promise<any[]>;
-/**
- * Get summarization statistics
- */
-export declare function getSummarizationStats(projectId?: string): Promise<{
-    totalSummaries: number;
-    byType: Record<string, number>;
-    totalTokensSaved: number;
-    avgCompressionRatio: number;
-}>;
-/**
- * Delete old summaries to save space
- */
-export declare function pruneOldSummaries(olderThanDays?: number): Promise<number>;
-//# sourceMappingURL=summarization.d.ts.map

package/dist/core/summarization.js

@@ -1,188 +0,0 @@
-/**
- * Aggressive Session Summarization
- * Implements incremental, rolling, and final summarization
- */
-import { eq, 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 } from './utils/summarization-helpers.js';
-import { extractMessageContent, generateExtractiveSummary } from './utils/content-extraction.js';
-import { logger } from './logger.js';
-const DEFAULT_CONFIG = {
-    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, summaryType, customConfig = {}) {
-    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
-            .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
-                .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.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, config) {
-    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, config) {
-    const window = getRollingWindow(messages, config.rollingWindowSize);
-    return generateExtractiveSummary(extractMessageContent(window));
-}
-/**
- * Create final summary (entire conversation)
- */
-async function createFinalSummary(messages, config) {
-    return generateExtractiveSummary(extractMessageContent(messages));
-}
-/**
- * Generate basic extractive summary of messages
- */
-function summarizeChunk(messages) {
-    if (messages.length === 0)
-        return '';
-    return generateExtractiveSummary(extractMessageContent(messages));
-}
-/**
- * Estimate tokens saved by summarization
- */
-function estimateTokensSaved(messages, summary) {
-    return calculateTokensSaved(messages, summary);
-}
-/**
- * Get recent summaries for a conversation
- */
-export async function getRecentSummaries(conversationId, limit = 10) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        return await db
-            .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) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const where = projectId ? eq(schema.sessionSummaries.projectId, projectId) : undefined;
-        const summaries = await db.select().from(schema.sessionSummaries).where(where);
-        const stats = {
-            totalSummaries: summaries.length,
-            byType: {
-                incremental: 0,
-                rolling: 0,
-                final: 0,
-            },
-            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 = 30) {
-    return cleanupOldSessionSummaries(olderThanDays);
-}
-//# sourceMappingURL=summarization.js.map