squish-memory 1.2.0 → 1.2.1

package/dist/core/session/working-set.js

@@ -1,212 +0,0 @@
-import { randomUUID } from 'crypto';
-import { eq } from 'drizzle-orm';
-import { getDbClient } from '../lib/db-client.js';
-import { ensureProject, getProjectByPath } from '../projects.js';
-import { deserializeMetadata, serializeMetadata } from '../memory/serialization.js';
-const EMPTY_WORKING_SET = (sessionId, projectPath) => ({
-    activeFiles: [],
-    activePlaces: [],
-    graphEntities: [],
-    recentCommands: [],
-    currentHypotheses: [],
-    recentFailures: [],
-    recentAttempts: [],
-    projectPath,
-    sessionId,
-    signalStats: {
-        captured: 0,
-        suppressed: 0,
-        sessionOnly: 0,
-        durable: 0,
-        durableWithRaw: 0,
-        tokensSaved: 0,
-        placeRouted: 0,
-        graphEnriched: 0,
-    },
-    recentEvents: [],
-});
-function dedupe(items, limit) {
-    return [...new Set(items.filter(Boolean))].slice(0, limit);
-}
-function normalizeSessionMetadata(metadata, sessionId, projectPath) {
-    const parsed = (metadata ?? {});
-    return {
-        ...EMPTY_WORKING_SET(sessionId, projectPath),
-        ...parsed,
-        activeFiles: parsed.activeFiles ?? [],
-        activePlaces: parsed.activePlaces ?? [],
-        graphEntities: parsed.graphEntities ?? [],
-        recentCommands: parsed.recentCommands ?? [],
-        currentHypotheses: parsed.currentHypotheses ?? [],
-        recentFailures: parsed.recentFailures ?? [],
-        recentAttempts: parsed.recentAttempts ?? [],
-        recentEvents: parsed.recentEvents ?? [],
-        signalStats: {
-            ...EMPTY_WORKING_SET(sessionId, projectPath).signalStats,
-            ...(parsed.signalStats ?? {}),
-        },
-    };
-}
-async function getOrCreateContextSession(sessionId, projectPath) {
-    const { db, schema, raw } = await getDbClient();
-    const project = await ensureProject(projectPath);
-    const existing = await db
-        .select()
-        .from(schema.contextSessions)
-        .where(eq(schema.contextSessions.sessionId, sessionId))
-        .limit(1);
-    if (existing[0])
-        return { row: existing[0], projectId: project?.id ?? null, db, schema };
-    const sqlite = raw.$client;
-    const id = randomUUID();
-    const metadata = serializeMetadata(EMPTY_WORKING_SET(sessionId, projectPath));
-    sqlite.prepare(`
-    INSERT INTO context_sessions (
-      id, session_id, project_id, metadata, token_budget, tokens_used, core_memory_tokens, loaded_memories_tokens, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, 8000, 0, 0, 0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
-  `).run(id, sessionId, project?.id ?? null, metadata);
-    const inserted = await db
-        .select()
-        .from(schema.contextSessions)
-        .where(eq(schema.contextSessions.sessionId, sessionId))
-        .limit(1);
-    return { row: inserted[0], projectId: project?.id ?? null, db, schema };
-}
-export async function getSessionWorkingSet(sessionId, projectPath) {
-    const { db, schema } = await getDbClient();
-    const rows = await db
-        .select()
-        .from(schema.contextSessions)
-        .where(eq(schema.contextSessions.sessionId, sessionId))
-        .limit(1);
-    if (!rows[0])
-        return EMPTY_WORKING_SET(sessionId, projectPath);
-    return normalizeSessionMetadata(deserializeMetadata(rows[0].metadata ?? null), sessionId, projectPath);
-}
-export async function recordSessionSignal(input) {
-    const { row, db, schema } = await getOrCreateContextSession(input.sessionId, input.projectPath);
-    const current = normalizeSessionMetadata(deserializeMetadata(row.metadata ?? null), input.sessionId, input.projectPath);
-    const meta = input.metadata ?? {};
-    const now = new Date().toISOString();
-    const next = normalizeSessionMetadata(current, input.sessionId, input.projectPath);
-    next.activeFiles = dedupe([
-        ...next.activeFiles,
-        ...((meta.activeFiles ?? [])),
-    ], 8);
-    next.activePlaces = dedupe([
-        ...next.activePlaces,
-        ...((meta.activePlaces ?? [])),
-    ], 6);
-    next.graphEntities = dedupe([
-        ...next.graphEntities,
-        ...((meta.graphEntities ?? [])),
-    ], 8);
-    const command = typeof meta.command === 'string' ? meta.command : undefined;
-    if (command) {
-        next.recentCommands = [{ command, outcome: typeof meta.outcome === 'string' ? meta.outcome : undefined, at: now }, ...next.recentCommands].slice(0, 8);
-    }
-    if (/hypothesis/i.test(input.distilledContent)) {
-        next.currentHypotheses = dedupe([input.distilledContent, ...next.currentHypotheses], 5);
-    }
-    if ((typeof meta.outcome === 'string' && meta.outcome === 'failure') || /fail|error|exception/i.test(input.distilledContent)) {
-        next.recentFailures = dedupe([input.target ?? input.distilledContent, ...next.recentFailures], 5);
-    }
-    next.recentAttempts = dedupe([input.distilledContent, ...next.recentAttempts], 8);
-    next.recentEvents = [
-        {
-            classification: input.classification,
-            content: input.distilledContent,
-            target: input.target,
-            hash: typeof meta.contentHash === 'string' ? meta.contentHash : undefined,
-            at: now,
-        },
-        ...next.recentEvents,
-    ].slice(0, 20);
-    if (input.classification === 'discard')
-        next.signalStats.suppressed += 1;
-    else
-        next.signalStats.captured += 1;
-    if (input.classification === 'session-only')
-        next.signalStats.sessionOnly += 1;
-    if (input.classification === 'durable-distilled')
-        next.signalStats.durable += 1;
-    if (input.classification === 'durable-raw+distilled')
-        next.signalStats.durableWithRaw += 1;
-    next.signalStats.tokensSaved += Number(meta.tokensSaved ?? 0);
-    next.signalStats.placeRouted += meta.placeRouted ? 1 : 0;
-    next.signalStats.graphEnriched += meta.graphEnriched ? 1 : 0;
-    await db
-        .update(schema.contextSessions)
-        .set({
-        metadata: serializeMetadata(next),
-        updatedAt: new Date(),
-    })
-        .where(eq(schema.contextSessions.sessionId, input.sessionId));
-    return next;
-}
-export async function compactSessionWorkingSet(sessionId, projectPath) {
-    const workingSet = await getSessionWorkingSet(sessionId, projectPath);
-    const lines = [];
-    if (workingSet.currentHypotheses.length > 0) {
-        lines.push(`Hypotheses: ${dedupe(workingSet.currentHypotheses, 3).join(' | ')}`);
-    }
-    if (workingSet.recentFailures.length > 0) {
-        lines.push(`Failures: ${dedupe(workingSet.recentFailures, 3).join(' | ')}`);
-    }
-    if (workingSet.activeFiles.length > 0) {
-        lines.push(`Active files: ${dedupe(workingSet.activeFiles, 5).join(', ')}`);
-    }
-    if (workingSet.activePlaces.length > 0) {
-        lines.push(`Active places: ${dedupe(workingSet.activePlaces, 4).join(', ')}`);
-    }
-    if (workingSet.graphEntities.length > 0) {
-        lines.push(`Graph entities: ${dedupe(workingSet.graphEntities, 4).join(', ')}`);
-    }
-    if (workingSet.recentCommands.length > 0) {
-        lines.push(`Recent commands: ${dedupe(workingSet.recentCommands.map((entry) => entry.command), 3).join(' | ')}`);
-    }
-    return {
-        summary: lines.join('\n'),
-        workingSet,
-    };
-}
-export async function getProjectSignalStats(projectPath) {
-    const { db, schema } = await getDbClient();
-    const project = await getProjectByPath(projectPath);
-    if (!project) {
-        return EMPTY_WORKING_SET('project-stats', projectPath).signalStats;
-    }
-    const rows = await db
-        .select()
-        .from(schema.contextSessions)
-        .where(eq(schema.contextSessions.projectId, project.id));
-    return rows.reduce((acc, row) => {
-        const workingSet = normalizeSessionMetadata(deserializeMetadata(row.metadata ?? null), row.sessionId, projectPath);
-        acc.captured += workingSet.signalStats.captured;
-        acc.suppressed += workingSet.signalStats.suppressed;
-        acc.sessionOnly += workingSet.signalStats.sessionOnly;
-        acc.durable += workingSet.signalStats.durable;
-        acc.durableWithRaw += workingSet.signalStats.durableWithRaw;
-        acc.tokensSaved += workingSet.signalStats.tokensSaved;
-        return acc;
-    }, { ...EMPTY_WORKING_SET('project-stats', projectPath).signalStats });
-}
-export async function getLatestProjectWorkingSetSummary(projectPath) {
-    const { db, schema } = await getDbClient();
-    const project = await getProjectByPath(projectPath);
-    if (!project)
-        return '';
-    const rows = await db
-        .select()
-        .from(schema.contextSessions)
-        .where(eq(schema.contextSessions.projectId, project.id));
-    const latest = rows.sort((a, b) => {
-        const left = new Date(a.updatedAt ?? a.createdAt ?? 0).getTime();
-        const right = new Date(b.updatedAt ?? b.createdAt ?? 0).getTime();
-        return right - left;
-    })[0];
-    if (!latest)
-        return '';
-    return compactSessionWorkingSet(latest.sessionId, projectPath).then((result) => result.summary);
-}
-//# sourceMappingURL=working-set.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/cleanup.js

@@ -1,12 +0,0 @@
-/**
- * Snapshot Cleanup Operations
- * Maintenance and cleanup for snapshot data
- */
-import { cleanupOldMemorySnapshots } from '../utils/cleanup-operations.js';
-/**
- * Delete old snapshots
- */
-export async function deleteOldSnapshots(olderThanDays = 90) {
-    return cleanupOldMemorySnapshots(olderThanDays);
-}
-//# sourceMappingURL=cleanup.js.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,13 +0,0 @@
-/**
- * Snapshot Creation Operations
- * Functions for creating different types of memory snapshots
- */
-import { MemoryDiff, calculateDiff } from './comparison.js';
-export { MemoryDiff, calculateDiff };
-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,117 +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';
-import { calculateDiff } from './comparison.js';
-// Re-export for convenience
-export { calculateDiff };
-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,
-    };
-}
-//# 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/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