squish-memory 1.1.5 → 1.2.1

package/dist/core/session-hooks/session-hooks.d.ts

@@ -1,18 +0,0 @@
-/** Session Hooks - Lifecycle hooks for conversation management
- *
- * Provides functions to be called when sessions start/end
- */
-/**
- * Called when a session ends
- * Marks the conversation as ended so self-iteration can process it
- */
-export declare function onSessionEnd(sessionId: string): Promise<void>;
-/**
- * Get active sessions for a project
- */
-export declare function getActiveSessions(projectId: string): Promise<string[]>;
-/**
- * End all sessions for a project
- */
-export declare function endAllProjectSessions(projectId: string): Promise<number>;
-//# sourceMappingURL=session-hooks.d.ts.map

package/dist/core/session-hooks/session-hooks.js

@@ -1,58 +0,0 @@
-/** Session Hooks - Lifecycle hooks for conversation management
- *
- * Provides functions to be called when sessions start/end
- */
-import { sql, eq } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-/**
- * Called when a session ends
- * Marks the conversation as ended so self-iteration can process it
- */
-export async function onSessionEnd(sessionId) {
-    logger.info(`[SessionHooks] Session ended: ${sessionId}`);
-    const db = await getDb();
-    if (!db) {
-        logger.warn('[SessionHooks] Database unavailable, cannot end session');
-        return;
-    }
-    const schema = await getSchema();
-    const sqliteDb = db;
-    // Mark conversation as ended
-    await sqliteDb.update(schema.conversations)
-        .set({ endedAt: new Date() })
-        .where(eq(schema.conversations.sessionId, sessionId));
-    logger.info(`[SessionHooks] Session ${sessionId} marked as ended`);
-}
-/**
- * Get active sessions for a project
- */
-export async function getActiveSessions(projectId) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const sessions = await sqliteDb.select()
-        .from(schema.conversations)
-        .where(eq(schema.conversations.projectId, projectId))
-        .where(sql `${schema.conversations.endedAt} IS NULL`);
-    return sessions.map((s) => s.session_id);
-}
-/**
- * End all sessions for a project
- */
-export async function endAllProjectSessions(projectId) {
-    const db = await getDb();
-    if (!db)
-        return 0;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const result = await sqliteDb.update(schema.conversations)
-        .set({ endedAt: new Date() })
-        .where(eq(schema.conversations.projectId, projectId));
-    logger.info(`[SessionHooks] Ended ${result.rowCount} sessions for project ${projectId}`);
-    return result.rowCount || 0;
-}
-//# sourceMappingURL=session-hooks.js.map

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

@@ -1,9 +0,0 @@
-/**
- * Snapshot Cleanup Operations
- * Maintenance and cleanup for snapshot data
- */
-/**
- * Delete old snapshots
- */
-export declare function deleteOldSnapshots(olderThanDays?: number): Promise<number>;
-//# sourceMappingURL=cleanup.d.ts.map

package/dist/core/snapshots/comparison.d.ts

@@ -1,19 +0,0 @@
-/**
- * Snapshot Comparison Operations
- * Functions for comparing and diffing snapshots
- */
-export interface MemoryDiff {
-    added?: string[];
-    removed?: string[];
-    changed?: Record<string, {
-        from: unknown;
-        to: unknown;
-    }>;
-}
-export declare function calculateDiff(before: string, after: string): MemoryDiff;
-export declare function compareSnapshots(snapshotId1: string, snapshotId2: string): Promise<{
-    diff: MemoryDiff;
-    contextBefore: string;
-    contextAfter: string;
-}>;
-//# sourceMappingURL=comparison.d.ts.map

package/dist/core/snapshots/comparison.js

@@ -1,43 +0,0 @@
-/**
- * Snapshot Comparison Operations
- * Functions for comparing and diffing snapshots
- */
-import { getMemorySnapshot } from './retrieval.js';
-import { logger } from '../logger.js';
-export function calculateDiff(before, after) {
-    const beforeLines = before === '' ? [] : before.split('\n');
-    const afterLines = after === '' ? [] : after.split('\n');
-    const beforeSet = new Set(beforeLines);
-    const afterSet = new Set(afterLines);
-    const added = afterLines.filter(line => !beforeSet.has(line));
-    const removed = beforeLines.filter(line => !afterSet.has(line));
-    if (added.length === 0 && removed.length === 0 && before !== after) {
-        return {
-            added: afterLines.length > 0 ? afterLines : undefined,
-            removed: beforeLines.length > 0 ? beforeLines : undefined,
-        };
-    }
-    return {
-        added: added.length > 0 ? added : undefined,
-        removed: removed.length > 0 ? removed : undefined,
-    };
-}
-export async function compareSnapshots(snapshotId1, snapshotId2) {
-    try {
-        const snap1 = await getMemorySnapshot(snapshotId1);
-        const snap2 = await getMemorySnapshot(snapshotId2);
-        if (!snap1 || !snap2) {
-            throw new Error('One or both snapshots not found');
-        }
-        return {
-            diff: calculateDiff(snap1.content, snap2.content),
-            contextBefore: snap1.content.substring(0, 200),
-            contextAfter: snap2.content.substring(0, 200),
-        };
-    }
-    catch (error) {
-        logger.error('Error comparing snapshots', error);
-        throw error;
-    }
-}
-//# sourceMappingURL=comparison.js.map

package/dist/core/snapshots/creation.d.ts

@@ -1,19 +0,0 @@
-/**
- * Snapshot Creation Operations
- * Functions for creating different types of memory snapshots
- */
-export interface MemoryDiff {
-    added?: string[];
-    removed?: string[];
-    changed?: Record<string, {
-        from: unknown;
-        to: unknown;
-    }>;
-}
-export declare function createBeforeSnapshot(memoryId: string): Promise<string>;
-export declare function createAfterSnapshot(memoryId: string, beforeSnapshotId: string): Promise<{
-    snapshotId: string;
-    diff: MemoryDiff;
-}>;
-export declare function createPeriodicSnapshot(memoryId: string): Promise<string>;
-//# sourceMappingURL=creation.d.ts.map

package/dist/core/snapshots/creation.js

@@ -1,126 +0,0 @@
-/**
- * Snapshot Creation Operations
- * Functions for creating different types of memory snapshots
- */
-import { eq } from 'drizzle-orm';
-import { randomUUID } from 'crypto';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-export async function createBeforeSnapshot(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found: ' + memoryId);
-        }
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'before_update',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            createdAt: new Date(),
-        });
-        return snapshotId;
-    }
-    catch (error) {
-        logger.error('Error creating before snapshot', error);
-        throw error;
-    }
-}
-export async function createAfterSnapshot(memoryId, beforeSnapshotId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found');
-        }
-        const before = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.id, beforeSnapshotId))
-            .limit(1);
-        if (before.length === 0) {
-            throw new Error('Before snapshot not found');
-        }
-        const diff = calculateDiff(before[0].content, memory[0].content);
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'after_update',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            diff,
-            createdAt: new Date(),
-        });
-        return { snapshotId, diff };
-    }
-    catch (error) {
-        logger.error('Error creating after snapshot', error);
-        throw error;
-    }
-}
-export async function createPeriodicSnapshot(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found');
-        }
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'periodic',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            createdAt: new Date(),
-        });
-        return snapshotId;
-    }
-    catch (error) {
-        logger.error('Error creating periodic snapshot', error);
-        throw error;
-    }
-}
-function extractMetadata(memory) {
-    return {
-        type: memory.type,
-        sector: memory.sector,
-        confidence: memory.confidence,
-        relevanceScore: memory.relevanceScore,
-        tags: memory.tags,
-        agentId: memory.agentId,
-    };
-}
-function calculateDiff(before, after) {
-    const beforeLines = before.split('\n');
-    const afterLines = after.split('\n');
-    const beforeSet = new Set(beforeLines);
-    const afterSet = new Set(afterLines);
-    const added = afterLines.filter(line => !beforeSet.has(line));
-    const removed = beforeLines.filter(line => !afterSet.has(line));
-    return {
-        added: added.length > 0 ? added : undefined,
-        removed: removed.length > 0 ? removed : undefined,
-    };
-}
-//# sourceMappingURL=creation.js.map

package/dist/core/snapshots/retrieval.d.ts

@@ -1,7 +0,0 @@
-/**
- * Snapshot Retrieval Operations
- * Functions for retrieving and querying snapshots
- */
-export declare function getMemoryHistory(memoryId: string, limit?: number): Promise<any[]>;
-export declare function getMemorySnapshot(snapshotId: string): Promise<any>;
-//# sourceMappingURL=retrieval.d.ts.map

package/dist/core/snapshots/retrieval.js

@@ -1,41 +0,0 @@
-/**
- * Snapshot Retrieval Operations
- * Functions for retrieving and querying snapshots
- */
-import { eq, desc } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-export async function getMemoryHistory(memoryId, limit = 50) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        return await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.memoryId, memoryId))
-            .orderBy(desc(schema.memorySnapshots.createdAt))
-            .limit(limit);
-    }
-    catch (error) {
-        logger.error('Error getting memory history', error);
-        return [];
-    }
-}
-export async function getMemorySnapshot(snapshotId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const snapshot = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.id, snapshotId))
-            .limit(1);
-        return snapshot.length > 0 ? snapshot[0] : null;
-    }
-    catch (error) {
-        logger.error('Error getting snapshot', error);
-        return null;
-    }
-}
-//# sourceMappingURL=retrieval.js.map

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

@@ -1,11 +0,0 @@
-/**
- * Snapshot Statistics
- * Analytics and statistics for snapshot operations
- */
-export declare function getSnapshotStats(memoryId?: string): Promise<{
-    totalSnapshots: number;
-    byType: Record<string, number>;
-    oldestSnapshot: Date | null;
-    newestSnapshot: Date | null;
-}>;
-//# sourceMappingURL=stats.d.ts.map

package/dist/core/snapshots/stats.js

@@ -1,52 +0,0 @@
-/**
- * Snapshot Statistics
- * Analytics and statistics for snapshot operations
- */
-import { eq } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-export async function getSnapshotStats(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const where = memoryId ? eq(schema.memorySnapshots.memoryId, memoryId) : undefined;
-        const snapshots = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(where);
-        const stats = {
-            totalSnapshots: snapshots.length,
-            byType: {
-                before_update: 0,
-                after_update: 0,
-                periodic: 0,
-            },
-            oldestSnapshot: null,
-            newestSnapshot: null,
-        };
-        let oldest = null;
-        let newest = null;
-        for (const snap of snapshots) {
-            stats.byType[snap.snapshotType]++;
-            const date = new Date(snap.createdAt);
-            if (!oldest || date < oldest)
-                oldest = date;
-            if (!newest || date > newest)
-                newest = date;
-        }
-        stats.oldestSnapshot = oldest;
-        stats.newestSnapshot = newest;
-        return stats;
-    }
-    catch (error) {
-        logger.error('Error getting snapshot stats', error);
-        return {
-            totalSnapshots: 0,
-            byType: {},
-            oldestSnapshot: null,
-            newestSnapshot: null,
-        };
-    }
-}
-//# sourceMappingURL=stats.js.map

package/dist/core/snapshots.d.ts

@@ -1,29 +0,0 @@
-export interface MemoryDiff {
-    added?: string[];
-    removed?: string[];
-    changed?: Record<string, {
-        from: unknown;
-        to: unknown;
-    }>;
-}
-export declare function createBeforeSnapshot(memoryId: string): Promise<string>;
-export declare function createAfterSnapshot(memoryId: string, beforeSnapshotId: string): Promise<{
-    snapshotId: string;
-    diff: MemoryDiff;
-}>;
-export declare function createPeriodicSnapshot(memoryId: string): Promise<string>;
-export declare function getMemoryHistory(memoryId: string, limit?: number): Promise<any[]>;
-export declare function getMemorySnapshot(snapshotId: string): Promise<any>;
-export declare function deleteOldSnapshots(olderThanDays?: number): Promise<number>;
-export declare function compareSnapshots(snapshotId1: string, snapshotId2: string): Promise<{
-    diff: MemoryDiff;
-    contextBefore: string;
-    contextAfter: string;
-}>;
-export declare function getSnapshotStats(memoryId?: string): Promise<{
-    totalSnapshots: number;
-    byType: Record<string, number>;
-    oldestSnapshot: Date | null;
-    newestSnapshot: Date | null;
-}>;
-//# sourceMappingURL=snapshots.d.ts.map

package/dist/core/snapshots.js

@@ -1,220 +0,0 @@
-// Memory Snapshots for Auditability & Diffs
-import { eq, desc } from 'drizzle-orm';
-import { randomUUID } from 'crypto';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { cleanupOldMemorySnapshots } from './utils/cleanup-operations.js';
-import { logger } from './logger.js';
-export async function createBeforeSnapshot(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found: ' + memoryId);
-        }
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'before_update',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            createdAt: new Date(),
-        });
-        return snapshotId;
-    }
-    catch (error) {
-        logger.error('Error creating before snapshot', error);
-        throw error;
-    }
-}
-export async function createAfterSnapshot(memoryId, beforeSnapshotId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found');
-        }
-        const before = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.id, beforeSnapshotId))
-            .limit(1);
-        if (before.length === 0) {
-            throw new Error('Before snapshot not found');
-        }
-        const diff = calculateDiff(before[0].content, memory[0].content);
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'after_update',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            diff,
-            createdAt: new Date(),
-        });
-        return { snapshotId, diff };
-    }
-    catch (error) {
-        logger.error('Error creating after snapshot', error);
-        throw error;
-    }
-}
-export async function createPeriodicSnapshot(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memory = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, memoryId))
-            .limit(1);
-        if (memory.length === 0) {
-            throw new Error('Memory not found');
-        }
-        const snapshotId = randomUUID();
-        await db.insert(schema.memorySnapshots).values({
-            id: snapshotId,
-            memoryId,
-            snapshotType: 'periodic',
-            content: memory[0].content,
-            metadata: extractMetadata(memory[0]),
-            createdAt: new Date(),
-        });
-        return snapshotId;
-    }
-    catch (error) {
-        logger.error('Error creating periodic snapshot', error);
-        throw error;
-    }
-}
-export async function getMemoryHistory(memoryId, limit = 50) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        return await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.memoryId, memoryId))
-            .orderBy(desc(schema.memorySnapshots.createdAt))
-            .limit(limit);
-    }
-    catch (error) {
-        logger.error('Error getting memory history', error);
-        return [];
-    }
-}
-export async function getMemorySnapshot(snapshotId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const snapshot = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(eq(schema.memorySnapshots.id, snapshotId))
-            .limit(1);
-        return snapshot.length > 0 ? snapshot[0] : null;
-    }
-    catch (error) {
-        logger.error('Error getting snapshot', error);
-        return null;
-    }
-}
-export async function deleteOldSnapshots(olderThanDays = 90) {
-    return cleanupOldMemorySnapshots(olderThanDays);
-}
-function extractMetadata(memory) {
-    return {
-        type: memory.type,
-        sector: memory.sector,
-        confidence: memory.confidence,
-        relevanceScore: memory.relevanceScore,
-        tags: memory.tags,
-        agentId: memory.agentId,
-    };
-}
-function calculateDiff(before, after) {
-    const beforeLines = before.split('\n');
-    const afterLines = after.split('\n');
-    const beforeSet = new Set(beforeLines);
-    const afterSet = new Set(afterLines);
-    const added = afterLines.filter(line => !beforeSet.has(line));
-    const removed = beforeLines.filter(line => !afterSet.has(line));
-    return {
-        added: added.length > 0 ? added : undefined,
-        removed: removed.length > 0 ? removed : undefined,
-    };
-}
-export async function compareSnapshots(snapshotId1, snapshotId2) {
-    try {
-        const snap1 = await getMemorySnapshot(snapshotId1);
-        const snap2 = await getMemorySnapshot(snapshotId2);
-        if (!snap1 || !snap2) {
-            throw new Error('One or both snapshots not found');
-        }
-        return {
-            diff: calculateDiff(snap1.content, snap2.content),
-            contextBefore: snap1.content.substring(0, 200),
-            contextAfter: snap2.content.substring(0, 200),
-        };
-    }
-    catch (error) {
-        logger.error('Error comparing snapshots', error);
-        throw error;
-    }
-}
-export async function getSnapshotStats(memoryId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const where = memoryId ? eq(schema.memorySnapshots.memoryId, memoryId) : undefined;
-        const snapshots = await db
-            .select()
-            .from(schema.memorySnapshots)
-            .where(where);
-        const stats = {
-            totalSnapshots: snapshots.length,
-            byType: {
-                before_update: 0,
-                after_update: 0,
-                periodic: 0,
-            },
-            oldestSnapshot: null,
-            newestSnapshot: null,
-        };
-        let oldest = null;
-        let newest = null;
-        for (const snap of snapshots) {
-            stats.byType[snap.snapshotType]++;
-            const date = new Date(snap.createdAt);
-            if (!oldest || date < oldest)
-                oldest = date;
-            if (!newest || date > newest)
-                newest = date;
-        }
-        stats.oldestSnapshot = oldest;
-        stats.newestSnapshot = newest;
-        return stats;
-    }
-    catch (error) {
-        logger.error('Error getting snapshot stats', error);
-        return {
-            totalSnapshots: 0,
-            byType: {},
-            oldestSnapshot: null,
-            newestSnapshot: null,
-        };
-    }
-}
-//# sourceMappingURL=snapshots.js.map

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

@@ -1,13 +0,0 @@
-export declare function cacheGet<T>(key: string): Promise<T | null>;
-export declare function cacheSet<T>(key: string, value: T, ttlMs?: number): Promise<void>;
-export declare function getCacheStats(): {
-    entries: number;
-    sizeBytes: number;
-    maxSize: number;
-    maxSizeBytes: number;
-    utilizationPercent: number;
-    memoryUtilizationPercent: number;
-};
-export declare function closeCache(): Promise<void>;
-export declare function checkRedisHealth(): Promise<boolean>;
-//# sourceMappingURL=cache.d.ts.map