squish-memory 1.2.0 → 1.2.1

package/dist/core/memory/consolidation.d.ts

@@ -1,42 +0,0 @@
-/**
- * Memory Consolidation System
- * Implements experience replay and memory consolidation
- */
-export interface ConsolidationOptions {
-    projectId: string;
-    minAge?: number;
-    maxImportance?: number;
-    minClusterSize?: number;
-    similarityThreshold?: number;
-    limit?: number;
-}
-export interface ConsolidationResult {
-    consolidatedMemoryId: string;
-    sourceMemoryIds: string[];
-    clusterSize: number;
-    summary: string;
-}
-export interface ClusterResult {
-    memories: any[];
-    similarity: number;
-    representativeId: string;
-}
-/**
- * Main consolidation function - consolidates low-importance old memories
- */
-export declare function consolidateMemories(options: ConsolidationOptions): Promise<ConsolidationResult[]>;
-/**
- * Reverse consolidation - restore original memories
- * This allows undoing consolidation if needed
- */
-export declare function reverseConsolidation(consolidatedMemoryId: string): Promise<void>;
-/**
- * Get consolidation statistics for a project
- */
-export declare function getConsolidationStats(projectId: string): Promise<{
-    totalMemories: number;
-    consolidatedMemories: number;
-    consolidationsCreated: number;
-    avgClusterSize: number;
-}>;
-//# sourceMappingURL=consolidation.d.ts.map

package/dist/core/memory/consolidation.js

@@ -1,277 +0,0 @@
-/**
- * Memory Consolidation System
- * Implements experience replay and memory consolidation
- */
-import { eq, inArray } from 'drizzle-orm';
-import { createDatabaseClient } from '../storage/database.js';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { cosineSimilarity } from '../utils/vector-operations.js';
-import { parseEmbedding } from '../lib/parse-embedding.js';
-import { getLowImportanceMemories } from './importance.js';
-import { rememberMemory } from './memories.js';
-import { logger } from '../logger.js';
-/**
- * Main consolidation function - consolidates low-importance old memories
- */
-export async function consolidateMemories(options) {
-    const { projectId, minAge = 90, maxImportance = 30, minClusterSize = 3, similarityThreshold = 0.7, limit = 100, } = options;
-    // Get low-importance, old memories
-    const candidates = await getLowImportanceMemories(projectId, {
-        minAge,
-        maxImportance,
-        limit,
-    });
-    if (candidates.length < minClusterSize) {
-        logger.debug('Not enough memories to consolidate', {
-            count: candidates.length,
-            minClusterSize,
-        });
-        return [];
-    }
-    // Cluster memories by similarity
-    const clusters = await clusterMemoriesBySimilarity(candidates, {
-        minClusterSize,
-        similarityThreshold,
-    });
-    logger.info(`Found ${clusters.length} memory clusters for consolidation`);
-    const results = [];
-    // Consolidate each cluster
-    for (const cluster of clusters) {
-        try {
-            const result = await consolidateCluster(cluster);
-            results.push(result);
-        }
-        catch (error) {
-            logger.error('Failed to consolidate cluster', error);
-        }
-    }
-    return results;
-}
-/**
- * Cluster memories by similarity using a simple greedy algorithm
- */
-async function clusterMemoriesBySimilarity(memories, options = {}) {
-    const { minClusterSize = 3, similarityThreshold = 0.7 } = options;
-    const clustered = new Set();
-    const clusters = [];
-    for (const memory of memories) {
-        if (clustered.has(memory.id))
-            continue;
-        // Find similar memories
-        const similar = [memory];
-        const similarities = [1];
-        for (const other of memories) {
-            if (other.id === memory.id)
-                continue;
-            if (clustered.has(other.id))
-                continue;
-            // Calculate similarity using embeddings
-            const sim = await calculateMemorySimilarity(memory, other);
-            if (sim >= similarityThreshold) {
-                similar.push(other);
-                similarities.push(sim);
-                clustered.add(other.id);
-            }
-        }
-        clustered.add(memory.id);
-        // Only keep clusters that meet minimum size
-        if (similar.length >= minClusterSize) {
-            const avgSimilarity = similarities.reduce((a, b) => a + b, 0) / similarities.length;
-            clusters.push({
-                memories: similar,
-                similarity: avgSimilarity,
-                representativeId: memory.id,
-            });
-        }
-    }
-    return clusters;
-}
-/**
- * Calculate similarity between two memories using their embeddings
- */
-async function calculateMemorySimilarity(memory1, memory2) {
-    let embedding1 = parseEmbedding(memory1.embedding) ?? parseEmbedding(memory1.embedding_json);
-    let embedding2 = parseEmbedding(memory2.embedding) ?? parseEmbedding(memory2.embedding_json);
-    if (!embedding1 || !embedding2) {
-        // Fallback to text similarity if embeddings not available
-        return textSimilarity(memory1.content, memory2.content);
-    }
-    return cosineSimilarity(embedding1, embedding2);
-}
-/**
- * Simple text similarity as fallback (Jaccard similarity of word sets)
- */
-function textSimilarity(text1, text2) {
-    const words1 = new Set(text1.toLowerCase().split(/\s+/).filter(w => w.length > 2));
-    const words2 = new Set(text2.toLowerCase().split(/\s+/).filter(w => w.length > 2));
-    if (words1.size === 0 && words2.size === 0)
-        return 1;
-    if (words1.size === 0 || words2.size === 0)
-        return 0;
-    const intersection = new Set([...words1].filter(w => words2.has(w)));
-    const union = new Set([...words1, ...words2]);
-    return intersection.size / union.size;
-}
-/**
- * Consolidate a cluster of memories into a single summary memory
- */
-async function consolidateCluster(cluster) {
-    const { memories } = cluster;
-    const sourceMemoryIds = memories.map((m) => m.id);
-    // Generate extractive summary
-    const summary = generateExtractiveSummary(memories);
-    // Create consolidated memory
-    const consolidated = await rememberMemory({
-        content: summary,
-        type: 'context',
-        metadata: {
-            consolidatedFrom: sourceMemoryIds,
-            consolidatedAt: new Date().toISOString(),
-            clusterSize: memories.length,
-            avgSimilarity: cluster.similarity,
-        },
-        tags: ['consolidated'],
-    });
-    // Mark originals as consolidated
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    await db
-        .update(schema.memories)
-        .set({
-        isConsolidated: 1,
-        consolidatedInto: consolidated.id,
-        consolidatedAt: new Date(),
-    })
-        .where(inArray(schema.memories.id, sourceMemoryIds));
-    logger.info('Consolidated memory cluster', {
-        consolidatedId: consolidated.id,
-        sourceCount: memories.length,
-        sourceIds: sourceMemoryIds,
-    });
-    return {
-        consolidatedMemoryId: consolidated.id,
-        sourceMemoryIds,
-        clusterSize: memories.length,
-        summary,
-    };
-}
-/**
- * Generate extractive summary from a cluster of memories
- * Uses text processing without requiring an LLM
- */
-function generateExtractiveSummary(memories) {
-    // Group by memory type
-    const byType = new Map();
-    for (const m of memories) {
-        const type = m.type ?? 'observation';
-        if (!byType.has(type)) {
-            byType.set(type, []);
-        }
-        byType.get(type).push(m);
-    }
-    const summaryParts = [];
-    // Add header with count
-    summaryParts.push(`Consolidated from ${memories.length} memories:`);
-    // Summarize each type
-    for (const [type, typeMemories] of byType.entries()) {
-        if (typeMemories.length === 1) {
-            summaryParts.push(`\n- ${type}: ${truncate(typeMemories[0].content, 100)}`);
-        }
-        else {
-            summaryParts.push(`\n- ${type}s (${typeMemories.length}):`);
-            // Extract key phrases from each memory
-            for (const m of typeMemories.slice(0, 3)) {
-                summaryParts.push(`  - ${truncate(m.content, 80)}`);
-            }
-            if (typeMemories.length > 3) {
-                summaryParts.push(`  - ...and ${typeMemories.length - 3} more`);
-            }
-        }
-    }
-    return summaryParts.join('\n');
-}
-/**
- * Truncate text to maximum length
- */
-function truncate(text, maxLength) {
-    if (text.length <= maxLength)
-        return text;
-    return text.substring(0, maxLength - 3) + '...';
-}
-/**
- * Reverse consolidation - restore original memories
- * This allows undoing consolidation if needed
- */
-export async function reverseConsolidation(consolidatedMemoryId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    // Get the consolidated memory
-    const consolidated = await db
-        .select()
-        .from(schema.memories)
-        .where(eq(schema.memories.id, consolidatedMemoryId))
-        .limit(1);
-    if (consolidated.length === 0) {
-        throw new Error(`Consolidated memory not found: ${consolidatedMemoryId}`);
-    }
-    const metadata = consolidated[0].metadata;
-    const sourceIds = metadata?.consolidatedFrom;
-    if (!sourceIds || sourceIds.length === 0) {
-        throw new Error('No source memories found in consolidated memory metadata');
-    }
-    // Restore original memories
-    await db
-        .update(schema.memories)
-        .set({
-        isConsolidated: 0,
-        consolidatedInto: null,
-        consolidatedAt: null,
-    })
-        .where(inArray(schema.memories.id, sourceIds));
-    // Delete the consolidated memory
-    await db
-        .delete(schema.memories)
-        .where(eq(schema.memories.id, consolidatedMemoryId));
-    logger.info('Reversed consolidation', {
-        consolidatedId: consolidatedMemoryId,
-        restoredCount: sourceIds.length,
-    });
-}
-/**
- * Get consolidation statistics for a project
- */
-export async function getConsolidationStats(projectId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    // Get all memories for project
-    const memories = await db
-        .select()
-        .from(schema.memories)
-        .where(eq(schema.memories.projectId, projectId))
-        .all();
-    const totalMemories = memories.length;
-    const consolidatedMemories = memories.filter((m) => m.isConsolidated).length;
-    // Get consolidation summaries (memories created by consolidation)
-    const consolidations = memories.filter((m) => {
-        const metadata = m.metadata;
-        return metadata?.consolidatedFrom && Array.isArray(metadata.consolidatedFrom);
-    });
-    const consolidationsCreated = consolidations.length;
-    // Calculate average cluster size
-    let totalClusterSize = 0;
-    for (const m of consolidations) {
-        const metadata = m.metadata;
-        totalClusterSize += metadata?.clusterSize || 0;
-    }
-    const avgClusterSize = consolidationsCreated > 0
-        ? totalClusterSize / consolidationsCreated
-        : 0;
-    return {
-        totalMemories,
-        consolidatedMemories,
-        consolidationsCreated,
-        avgClusterSize,
-    };
-}
-//# sourceMappingURL=consolidation.js.map

package/dist/core/memory/context-collector.d.ts

@@ -1,10 +0,0 @@
-/** Context Collector - Collect recent conversation context for query rewriting */
-export interface ContextMessage {
-    role: 'user' | 'assistant';
-    content: string;
-    createdAt: Date;
-}
-export declare function collectRecentContext(sessionId: string, count?: number): Promise<ContextMessage[]>;
-export declare function formatContextForLLM(messages: ContextMessage[]): string;
-export declare function getLastUserMessages(sessionId: string, count?: number): Promise<string[]>;
-//# sourceMappingURL=context-collector.d.ts.map

package/dist/core/memory/context-collector.js

@@ -1,56 +0,0 @@
-/** Context Collector - Collect recent conversation context for query rewriting */
-import { logger } from '../logger.js';
-import { getDb } from '../../db/index.js';
-import { messages, conversations } from '../../db/drizzle/schema-sqlite.js';
-import { eq, desc } from 'drizzle-orm';
-export async function collectRecentContext(sessionId, count = 5) {
-    const db = await getDb();
-    if (!db) {
-        logger.warn('[ContextCollector] Database not available');
-        return [];
-    }
-    try {
-        const sqliteDb = db;
-        const [conversation] = await sqliteDb
-            .select()
-            .from(conversations)
-            .where(eq(conversations.sessionId, sessionId))
-            .orderBy(desc(conversations.startedAt))
-            .limit(1);
-        if (!conversation) {
-            logger.debug(`[ContextCollector] No conversation found for session ${sessionId}`);
-            return [];
-        }
-        const recentMessages = await sqliteDb
-            .select()
-            .from(messages)
-            .where(eq(messages.conversationId, conversation.id))
-            .orderBy(desc(messages.createdAt))
-            .limit(count);
-        const ordered = recentMessages.reverse();
-        return ordered.map((msg) => ({
-            role: msg.role,
-            content: msg.content,
-            createdAt: new Date(msg.createdAt ?? Date.now()),
-        }));
-    }
-    catch (error) {
-        logger.error('[ContextCollector] Failed to collect context:', error);
-        return [];
-    }
-}
-export function formatContextForLLM(messages) {
-    if (messages.length === 0)
-        return '';
-    return messages
-        .map(msg => `${msg.role === 'user' ? 'User' : 'Assistant'}: ${msg.content}`)
-        .join('\n\n');
-}
-export async function getLastUserMessages(sessionId, count = 3) {
-    const context = await collectRecentContext(sessionId, count * 2);
-    return context
-        .filter(msg => msg.role === 'user')
-        .slice(-count)
-        .map(msg => msg.content);
-}
-//# sourceMappingURL=context-collector.js.map

package/dist/core/memory/contradiction-resolver.d.ts

@@ -1,40 +0,0 @@
-/**
- * Contradiction Resolver
- * Detects and auto-resolves contradictions when writing new memories
- * Implements supersession logic for outdated information
- */
-export interface ContradictionResult {
-    hasContradiction: boolean;
-    supersededMemories: string[];
-    confidence: number;
-    reason: string;
-}
-export interface ContradictionCheck {
-    newContent: string;
-    newType: string;
-    projectId?: string;
-    entities?: string[];
-}
-/**
- * Detect contradictions between new memory and existing memories
- */
-export declare function detectContradictions(check: ContradictionCheck): Promise<ContradictionResult>;
-/**
- * Apply supersession to memories - archive old ones and create associations
- */
-export declare function applySupersession(newMemoryId: string, supersededIds: string[], confidence: number): Promise<void>;
-/**
- * Check for temporal contradictions (facts that are no longer valid)
- */
-export declare function checkTemporalContradictions(content: string, projectId?: string): Promise<string[]>;
-/**
- * Integrated contradiction resolution for the write path
- * Call this before storing a new memory
- */
-export declare function resolveContradictions(content: string, type: string, projectId?: string): Promise<{
-    shouldProceed: boolean;
-    supersededIds: string[];
-    confidence: number;
-    reason: string;
-}>;
-//# sourceMappingURL=contradiction-resolver.d.ts.map