squish-memory 1.1.5 → 1.2.1

package/dist/core/associations.js

@@ -1,248 +0,0 @@
-/**
- * Memory Association Graph (Waypoint Graph)
- * Tracks co-occurrence and relationships between memories
- */
-import { eq, and, or, desc, inArray, sql } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { logger } from './logger.js';
-/**
- * Create or update an association between two memories
- */
-export async function createAssociation(fromMemoryId, toMemoryId, type, weight = 1) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Check if association already exists
-        const existing = await db
-            .select()
-            .from(schema.memoryAssociations)
-            .where(and(eq(schema.memoryAssociations.fromMemoryId, fromMemoryId), eq(schema.memoryAssociations.toMemoryId, toMemoryId)))
-            .limit(1);
-        if (existing.length > 0) {
-            // Update weight and coactivation count
-            await db
-                .update(schema.memoryAssociations)
-                .set({
-                weight: existing[0].weight + weight,
-                coactivationCount: existing[0].coactivationCount + 1,
-                lastCoactivatedAt: new Date(),
-            })
-                .where(eq(schema.memoryAssociations.id, existing[0].id));
-        }
-        else {
-            // Create new association
-            await db.insert(schema.memoryAssociations).values({
-                fromMemoryId,
-                toMemoryId,
-                associationType: type,
-                weight,
-                coactivationCount: 1,
-                lastCoactivatedAt: new Date(),
-            });
-        }
-    }
-    catch (error) {
-        logger.error('Error creating association', error);
-    }
-}
-/**
- * Track co-activation of multiple memories (used together)
- */
-export async function trackCoactivation(memoryIds) {
-    if (memoryIds.length < 2)
-        return;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        // Generate all pairs
-        const pairs = [];
-        for (let i = 0; i < memoryIds.length; i++) {
-            for (let j = i + 1; j < memoryIds.length; j++) {
-                pairs.push({ from: memoryIds[i], to: memoryIds[j] });
-                pairs.push({ from: memoryIds[j], to: memoryIds[i] }); // Bidirectional
-            }
-        }
-        if (pairs.length === 0)
-            return;
-        // Batch check existing associations with single SELECT
-        const pairIds = pairs.map(p => ({ from: p.from, to: p.to }));
-        // Check which pairs already exist
-        const existingPairs = await db
-            .select({ fromId: schema.memoryAssociations.fromMemoryId, toId: schema.memoryAssociations.toMemoryId })
-            .from(schema.memoryAssociations)
-            .where(or(...pairIds.map((p) => and(eq(schema.memoryAssociations.fromMemoryId, p.from), eq(schema.memoryAssociations.toMemoryId, p.to)))));
-        const existingMap = new Set(existingPairs.map((p) => `${p.fromId}:${p.toId}`));
-        // Separate into new pairs and existing pairs
-        const newPairs = [];
-        const existingPairsToUpdate = [];
-        for (const pair of pairs) {
-            const key = `${pair.from}:${pair.to}`;
-            if (existingMap.has(key)) {
-                existingPairsToUpdate.push(key);
-            }
-            else {
-                newPairs.push({
-                    fromMemoryId: pair.from,
-                    toMemoryId: pair.to,
-                    associationType: 'co_occurred',
-                    weight: 1,
-                    coactivationCount: 1,
-                    lastCoactivatedAt: now,
-                });
-            }
-        }
-        // Bulk insert new associations
-        if (newPairs.length > 0) {
-            const BATCH_SIZE = 100;
-            for (let i = 0; i < newPairs.length; i += BATCH_SIZE) {
-                const batch = newPairs.slice(i, i + BATCH_SIZE);
-                try {
-                    // For PostgreSQL with ON CONFLICT support
-                    if (db.insert && db.onConflict) {
-                        await db
-                            .insert(schema.memoryAssociations)
-                            .values(batch)
-                            .onConflict({
-                            target: [schema.memoryAssociations.fromMemoryId, schema.memoryAssociations.toMemoryId],
-                            set: {
-                                weight: sql.raw('EXCLUDED.weight'),
-                                coactivationCount: sql.raw('EXCLUDED.coactivation_count'),
-                                lastCoactivatedAt: now,
-                            },
-                        })
-                            .catch(() => {
-                            // Fallback for SQLite
-                            return db.insert(schema.memoryAssociations).values(batch);
-                        });
-                    }
-                    else {
-                        // Direct insert for SQLite
-                        await db.insert(schema.memoryAssociations).values(batch);
-                    }
-                }
-                catch (error) {
-                    logger.error('Error inserting batch of associations', { batchSize: batch.length, error });
-                }
-            }
-        }
-        // Bulk update existing associations
-        if (existingPairsToUpdate.length > 0) {
-            const BATCH_SIZE = 100;
-            for (let i = 0; i < existingPairsToUpdate.length; i += BATCH_SIZE) {
-                const batch = existingPairsToUpdate.slice(i, i + BATCH_SIZE);
-                // Extract from/to pairs for this batch
-                const batchPairs = batch.map(key => {
-                    const [from, to] = key.split(':');
-                    return { from, to };
-                });
-                try {
-                    for (const pair of batchPairs) {
-                        await db
-                            .update(schema.memoryAssociations)
-                            .set({
-                            weight: sql `${schema.memoryAssociations.weight} + 1`,
-                            coactivationCount: sql `${schema.memoryAssociations.coactivationCount} + 1`,
-                            lastCoactivatedAt: now,
-                        })
-                            .where(and(eq(schema.memoryAssociations.fromMemoryId, pair.from), eq(schema.memoryAssociations.toMemoryId, pair.to)));
-                    }
-                }
-                catch (error) {
-                    logger.error('Error updating batch of associations', { batchSize: batch.length, error });
-                }
-            }
-        }
-        logger.debug('Coactivation tracked', {
-            totalPairs: pairs.length,
-            newAssociations: newPairs.length,
-            updatedAssociations: existingPairsToUpdate.length,
-        });
-    }
-    catch (error) {
-        logger.error('Error tracking coactivation', error);
-    }
-}
-/**
- * Get related memories via the association graph
- */
-export async function getRelatedMemories(memoryId, limit = 10) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get all associated memories, sorted by weight
-        const associations = await db
-            .select()
-            .from(schema.memoryAssociations)
-            .where(or(eq(schema.memoryAssociations.fromMemoryId, memoryId), eq(schema.memoryAssociations.toMemoryId, memoryId)))
-            .orderBy(desc(schema.memoryAssociations.weight))
-            .limit(limit);
-        const relatedIds = associations.map((a) => a.fromMemoryId === memoryId ? a.toMemoryId : a.fromMemoryId);
-        if (relatedIds.length === 0)
-            return [];
-        // Fetch the actual memories
-        return await db
-            .select()
-            .from(schema.memories)
-            .where(inArray(schema.memories.id, relatedIds));
-    }
-    catch (error) {
-        logger.error('Error getting related memories', error);
-        return [];
-    }
-}
-/**
- * Prune weak associations (weight < threshold)
- */
-export async function pruneWeakAssociations(weightThreshold = 5) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const result = await db
-            .delete(schema.memoryAssociations)
-            .where(schema.memoryAssociations.weight <= weightThreshold);
-        return result?.rowCount || 0;
-    }
-    catch (error) {
-        logger.error('Error pruning weak associations', error);
-        return 0;
-    }
-}
-/**
- * Get association statistics
- */
-export async function getAssociationStats() {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const associations = await db
-            .select()
-            .from(schema.memoryAssociations);
-        const stats = {
-            totalAssociations: associations.length,
-            byType: {},
-            avgWeight: 0,
-            maxWeight: 0,
-        };
-        let totalWeight = 0;
-        for (const assoc of associations) {
-            stats.byType[assoc.associationType] = (stats.byType[assoc.associationType] || 0) + 1;
-            totalWeight += assoc.weight;
-            if (assoc.weight > stats.maxWeight)
-                stats.maxWeight = assoc.weight;
-        }
-        stats.avgWeight = associations.length > 0 ? totalWeight / associations.length : 0;
-        return stats;
-    }
-    catch (error) {
-        logger.error('Error getting association stats', error);
-        return {
-            totalAssociations: 0,
-            byType: {},
-            avgWeight: 0,
-            maxWeight: 0,
-        };
-    }
-}
-//# sourceMappingURL=associations.js.map

package/dist/core/autosave.d.ts

@@ -1,19 +0,0 @@
-export declare function getDefaultAutosaveHook(): {
-    getMessageCount: () => number;
-    updateConfig: (opts?: {
-        enabled?: boolean;
-        messageCount?: number;
-        hooks?: string[];
-    }) => void;
-    getConfig: () => {
-        enabled: boolean;
-        messageCount: number;
-        hooks: string[];
-    };
-};
-export declare function createAutosaveConfig(): {
-    enabled: boolean;
-    messageCount: number;
-    hooks: string[];
-};
-//# sourceMappingURL=autosave.d.ts.map

package/dist/core/autosave.js

@@ -1,16 +0,0 @@
-// Autosave functionality placeholder
-export function getDefaultAutosaveHook() {
-    let config = { enabled: false, messageCount: 10, hooks: [] };
-    return {
-        getMessageCount: () => 0,
-        updateConfig: (opts) => {
-            if (opts)
-                Object.assign(config, opts);
-        },
-        getConfig: () => ({ ...config })
-    };
-}
-export function createAutosaveConfig() {
-    return { enabled: false, messageCount: 10, hooks: [] };
-}
-//# sourceMappingURL=autosave.js.map

package/dist/core/commands/managed-sync.d.ts

@@ -1,10 +0,0 @@
-export declare class ManagedSync {
-    private client;
-    private syncEnabled;
-    constructor();
-    sync(): Promise<void>;
-    pushMemory(memoryId: string): Promise<void>;
-    pullMemory(memoryId: string): Promise<void>;
-}
-export declare function startManagedSync(): Promise<ManagedSync>;
-//# sourceMappingURL=managed-sync.d.ts.map

package/dist/core/commands/managed-sync.js

@@ -1,64 +0,0 @@
-import { MCPClient } from '../../core/mcp/client.js';
-import { config } from '../../config.js';
-import { logger } from '../../core/logger.js';
-import { search, rememberMemory } from '../../core/memory/memories.js';
-export class ManagedSync {
-    client;
-    syncEnabled;
-    constructor() {
-        this.syncEnabled = config.managedMode && !!config.managedApiKey;
-        this.client = new MCPClient(config.managedApiUrl);
-    }
-    async sync() {
-        if (!this.syncEnabled) {
-            logger.debug('Managed sync disabled');
-            return;
-        }
-        try {
-            await this.client.initialize();
-            logger.info('Connected to managed storage');
-        }
-        catch (error) {
-            logger.error('Managed sync connection failed:', error);
-        }
-    }
-    async pushMemory(memoryId) {
-        if (!this.syncEnabled)
-            return;
-        try {
-            const memory = await search({ query: memoryId, limit: 1 });
-            if (memory.length > 0) {
-                await this.client.callTool('managed_memory_store', {
-                    memory: memory[0],
-                });
-                logger.debug(`Pushed memory ${memoryId} to managed storage`);
-            }
-        }
-        catch (error) {
-            logger.error(`Failed to push memory ${memoryId}:`, error);
-        }
-    }
-    async pullMemory(memoryId) {
-        if (!this.syncEnabled)
-            return;
-        try {
-            const result = await this.client.callTool('managed_memory_retrieve', {
-                memoryId,
-            });
-            if (result.content[0]?.text) {
-                const memory = JSON.parse(result.content[0].text);
-                await rememberMemory(memory);
-                logger.debug(`Pulled memory ${memoryId} from managed storage`);
-            }
-        }
-        catch (error) {
-            logger.error(`Failed to pull memory ${memoryId}:`, error);
-        }
-    }
-}
-export async function startManagedSync() {
-    const sync = new ManagedSync();
-    await sync.sync();
-    return sync;
-}
-//# sourceMappingURL=managed-sync.js.map

package/dist/core/commands/mcp-server.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=mcp-server.d.ts.map