squish-memory 1.0.2 → 1.1.5

package/dist/core/search/graph-boost.js

@@ -0,0 +1,23 @@
+import { getDb } from '../../db/index.js';
+import { memoryAssociations } from '../../db/drizzle/schema.js';
+import { inArray } from 'drizzle-orm';
+/**
+ * Compute a simple graph boost for a set of memory IDs.
+ * For each memory, sum (weight * coactivationCount) of outgoing associations.
+ * Returns a map from memoryId to boost value (default 0).
+ */
+export async function computeGraphBoost(memoryIds) {
+    const boost = {};
+    if (memoryIds.length === 0)
+        return boost;
+    const db = await getDb();
+    // @ts-ignore - drizzle overload
+    const rows = await db.select().from(memoryAssociations).where(inArray(memoryAssociations.fromMemoryId, memoryIds));
+    for (const row of rows) {
+        const from = row.fromMemoryId;
+        const val = (row.weight ?? 0) * (row.coactivationCount ?? 0);
+        boost[from] = (boost[from] ?? 0) + val;
+    }
+    return boost;
+}
+//# sourceMappingURL=graph-boost.js.map

package/dist/core/search/qmd-search.js

@@ -15,7 +15,7 @@
  * GitHub: https://github.com/tobi/qmd
  */
 import { getQMDClient } from '../embeddings/qmd-client.js';
-import { searchMemories } from '../memory/memories.js';
+import { search } from '../memory/memories.js';
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
 /**
@@ -29,7 +29,7 @@ export async function searchWithQMD(options) {
     if (!(await client.isAvailable())) {
         logger.warn('QMD unavailable, falling back to Squish search');
         // Fallback to Squish search
-        const squishResults = await searchMemories(options);
+        const squishResults = await search(options);
         return squishResults.map((r) => ({
             ...r,
             source: 'squish'
@@ -73,7 +73,7 @@ export async function searchWithQMD(options) {
     catch (error) {
         logger.error(`QMD search failed: ${error}`);
         // Fallback to Squish search
-        const squishResults = await searchMemories(options);
+        const squishResults = await search(options);
         return squishResults.map((r) => ({
             ...r,
             source: 'squish'
@@ -93,7 +93,7 @@ export async function fusedSearch(options) {
     const qmdAvailable = await client.isAvailable();
     // Run searches in parallel
     const results = await Promise.allSettled([
-        searchMemories(options),
+        search(options),
         qmdAvailable ? searchWithQMD({ ...options, includeSquishResults: false }) : []
     ]);
     const squishResults = results[0].status === 'fulfilled'

package/dist/core/security/encrypt.d.ts

@@ -0,0 +1,6 @@
+export declare function encrypt(plain: string, passphrase?: string): {
+    ciphertext: string;
+    nonce: string;
+};
+export declare function decrypt(ciphertext: string, nonceB64: string, passphrase?: string): string;
+//# sourceMappingURL=encrypt.d.ts.map

package/dist/core/security/encrypt.js

@@ -0,0 +1,47 @@
+import { randomBytes, pbkdf2Sync, createCipheriv, createDecipheriv } from 'crypto';
+import { config } from '../../config.js';
+const ITERATIONS = 100_000;
+const KEY_LEN = 32; // 256-bit
+const DIGEST = 'sha256';
+const ALGO = 'aes-256-gcm';
+const NONCE_LEN = 12;
+/**
+ * Derive a symmetric key from the passphrase and a salt.
+ * The salt is stored in `.squish/salt` (plain text) and is generated once.
+ */
+function getSalt() {
+    const fs = require('fs');
+    const path = require('path');
+    const saltPath = path.join(config.dataDir, 'salt');
+    if (!fs.existsSync(saltPath)) {
+        const salt = randomBytes(16).toString('hex');
+        fs.writeFileSync(saltPath, salt);
+        return Buffer.from(salt, 'hex');
+    }
+    return Buffer.from(fs.readFileSync(saltPath, 'utf-8'), 'hex');
+}
+function deriveKey(passphrase) {
+    const salt = getSalt();
+    return pbkdf2Sync(passphrase, salt, ITERATIONS, KEY_LEN, DIGEST);
+}
+export function encrypt(plain, passphrase) {
+    const key = deriveKey(passphrase || config.encryptionPassphrase);
+    const nonce = randomBytes(NONCE_LEN);
+    const cipher = createCipheriv(ALGO, key, nonce);
+    const encrypted = Buffer.concat([cipher.update(plain, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const ciphertext = Buffer.concat([encrypted, tag]).toString('base64');
+    return { ciphertext, nonce: nonce.toString('base64') };
+}
+export function decrypt(ciphertext, nonceB64, passphrase) {
+    const key = deriveKey(passphrase || config.encryptionPassphrase);
+    const nonce = Buffer.from(nonceB64, 'base64');
+    const data = Buffer.from(ciphertext, 'base64');
+    const tag = data.slice(data.length - 16);
+    const encrypted = data.slice(0, data.length - 16);
+    const decipher = createDecipheriv(ALGO, key, nonce);
+    decipher.setAuthTag(tag);
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    return decrypted.toString('utf8');
+}
+//# sourceMappingURL=encrypt.js.map

package/dist/core/{governance.d.ts → security/governance.d.ts}

@@ -16,6 +16,11 @@ export declare function pinMemory(memoryId: string): Promise<void>;
 export declare function unpinMemory(memoryId: string): Promise<void>;
 /**
  * Get all pinned memories for auto-injection into context
+ * Works regardless of governance settings - pinned memories should always be accessible
  */
-export declare function getPinnedMemories(): Promise<any[]>;
+export declare function getPinnedMemories(projectId?: string): Promise<any[]>;
+/**
+ * Get pinned memories formatted for context injection
+ */
+export declare function getPinnedMemoriesForContext(projectId?: string): Promise<string[]>;
 //# sourceMappingURL=governance.d.ts.map

package/dist/core/security/governance.js

@@ -0,0 +1,79 @@
+/**
+ * Memory Governance
+ * Implements protection, pinning, and immutability rules
+ */
+import { eq } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { performMemoryOperation } from '../utils/memory-operations.js';
+import { logger } from '../logger.js';
+import { createDatabaseClient } from '../storage/database.js';
+/**
+ * Mark a memory as protected (cannot be evicted)
+ */
+export async function protectMemory(memoryId, reason) {
+    await performMemoryOperation(memoryId, {
+        name: 'protecting memory',
+        updates: {
+            isProtected: true,
+            metadata: { protectionReason: reason, protectedAt: new Date().toISOString() },
+        },
+    });
+}
+/**
+ * Pin a memory for automatic injection into context
+ */
+export async function pinMemory(memoryId) {
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    await db
+        .update(schema.memories)
+        .set({
+        isPinned: true,
+        importanceScore: 100,
+        lastImportanceRecalc: new Date(),
+    })
+        .where(eq(schema.memories.id, memoryId));
+}
+/**
+ * Unpin a memory
+ */
+export async function unpinMemory(memoryId) {
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    await db
+        .update(schema.memories)
+        .set({
+        isPinned: false,
+        lastImportanceRecalc: new Date(),
+    })
+        .where(eq(schema.memories.id, memoryId));
+}
+/**
+ * Get all pinned memories for auto-injection into context
+ * Works regardless of governance settings - pinned memories should always be accessible
+ */
+export async function getPinnedMemories(projectId) {
+    try {
+        const db = await getDb();
+        const schema = await getSchema();
+        let query = db
+            .select()
+            .from(schema.memories)
+            .where(eq(schema.memories.isPinned, true))
+            .limit(50);
+        return await query;
+    }
+    catch (error) {
+        logger.error('Error retrieving pinned memories', error);
+        return [];
+    }
+}
+/**
+ * Get pinned memories formatted for context injection
+ */
+export async function getPinnedMemoriesForContext(projectId) {
+    const pinned = await getPinnedMemories(projectId);
+    return pinned.map(m => `[Pinned] ${m.content?.substring(0, 500) || '(no content)'}`);
+}
+//# sourceMappingURL=governance.js.map

package/dist/core/session/auto-load.js

@@ -1,10 +1,10 @@
 /** Session Auto-Load - Automatically load context when MCP session initializes */
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
-import { initializeCoreMemory, getCoreMemory } from '../core-memory.js';
-import { searchMemories } from '../memory/memories.js';
-import { getProjectContext } from '../context.js';
-import { ensureProject } from '../projects.js';
+import { initializeCoreMemory, getCoreMemory } from '../ingestion/core-memory.js';
+import { search } from '../memory/memories.js';
+import { getProjectContext } from '../context/context.js';
+import { getOrCreateProject } from '../projects.js';
 import { DEFAULT_AUTO_LOAD_CONFIG } from './types.js';
 function estimateTokens(text) {
     return Math.ceil(text.length / 4);
@@ -26,7 +26,7 @@ export async function performAutoLoad(projectPath, customConfig) {
         return result;
     }
     try {
-        const project = await ensureProject(projectPath);
+        const project = await getOrCreateProject(projectPath);
         if (!project) {
             result.warnings.push(`Failed to create/find project: ${projectPath}`);
             result.duration = Date.now() - startTime;
@@ -52,7 +52,7 @@ export async function performAutoLoad(projectPath, customConfig) {
         }
         if (cfg.includeRecentMemories && cfg.recentMemoryCount > 0) {
             try {
-                const recentMemories = await searchMemories({
+                const recentMemories = await search({
                     query: '',
                     project: projectPath,
                     limit: cfg.recentMemoryCount,

package/dist/core/session/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Session Module
- * v0.10.0 - Session management and auto-load
+ * Session management and auto-load
  */
 export * from './types.js';
 export * from './auto-load.js';

package/dist/core/session/index.js

@@ -1,6 +1,6 @@
 /**
  * Session Module
- * v0.10.0 - Session management and auto-load
+ * Session management and auto-load
  */
 export * from './types.js';
 export * from './auto-load.js';

package/dist/core/session/self-iteration-job.d.ts

@@ -0,0 +1,20 @@
+/** Self-Iteration Job - Auto-extract key facts from ended conversations
+ *
+ * Processes conversations to extract memories and generate summaries
+ */
+import { type JobHandler } from '../scheduler/cron-scheduler.js';
+export interface SelfIterationConfig {
+    enabled: boolean;
+    extractFacts: boolean;
+    generateSummaries: boolean;
+    consolidateMemories: boolean;
+    minMessageCount: number;
+    maxMessagesToProcess: number;
+}
+declare const DEFAULT_CONFIG: SelfIterationConfig;
+/**
+ * Register self-iteration job handler
+ */
+declare const selfIterationHandler: JobHandler;
+export { selfIterationHandler, DEFAULT_CONFIG };
+//# sourceMappingURL=self-iteration-job.d.ts.map

package/dist/core/session/self-iteration-job.js

@@ -0,0 +1,282 @@
+/** Self-Iteration Job - Auto-extract key facts from ended conversations
+ *
+ * Processes conversations to extract memories and generate summaries
+ */
+import { sql, eq } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { rememberMemory } from '../memory/memories.js';
+import { logger } from '../logger.js';
+const DEFAULT_CONFIG = {
+    enabled: true,
+    extractFacts: true,
+    generateSummaries: true,
+    consolidateMemories: true,
+    minMessageCount: 5,
+    maxMessagesToProcess: 50,
+};
+/**
+ * Build fact extraction prompt
+ */
+function buildFactExtractionPrompt(messages) {
+    const messagesText = messages.map(m => `[${m.role}]: ${m.content}`).join('\n\n');
+    return `Extract key facts, decisions, and user preferences from this conversation.
+
+Format your response as JSON:
+{
+  "extractedFacts": [
+    {
+      "content": "specific fact text",
+      "type": "fact|decision|preference|observation",
+      "confidence": 0-100
+    }
+  ]
+}
+
+Only extract truly meaningful information that should be remembered:
+- Facts that are useful for future work or decisions
+- User preferences and choices
+- Important decisions made
+- Patterns or behaviors observed
+
+Do NOT extract:
+- Temporary conversational details
+- Greetings or pleasantries
+- Unless they indicate something significant
+
+Conversation messages:
+${messagesText}`;
+}
+/**
+ * Build summary generation prompt
+ */
+function buildSummaryPrompt(messages) {
+    const messagesText = messages.map(m => `[${m.role}]: ${m.content}`).join('\n\n');
+    return `Generate a concise summary of this conversation (2-3 sentences, under 300 characters).
+
+Focus on:
+- What was accomplished
+- Key decisions made
+- Important context established
+
+Conversation messages:
+${messagesText}`;
+}
+/**
+ * Parse LLM fact extraction response
+ */
+function parseExtractedFacts(llmResponse) {
+    try {
+        const jsonMatch = llmResponse.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return [];
+        const json = JSON.parse(jsonMatch[0]);
+        return json.extractedFacts || [];
+    }
+    catch {
+        logger.warn('[SelfIteration] Failed to parse fact extraction response');
+        return [];
+    }
+}
+/**
+ * Get conversations ready for self-iteration
+ */
+async function getConversationsForIteration(maxMessages) {
+    const db = await getDb();
+    if (!db)
+        return [];
+    const schema = await getSchema();
+    const sqliteDb = db;
+    // Get conversations that:
+    // 1. Have ended (endedAt is not null)
+    // 2. Haven't been processed yet (metadata.selfIterationProcessed is not set)
+    // 3. Have enough messages (messageCount >= minMessageCount)
+    const conversations = await sqliteDb.select()
+        .from(schema.conversations)
+        .where(sql `${schema.conversations.endedAt} IS NOT NULL
+      AND (${schema.conversations.metadata}->>'selfIterationProcessed') IS NULL
+      AND ${schema.conversations.messageCount} >= ?`)
+        .limit(10);
+    return conversations;
+}
+/**
+ * Get messages for a conversation
+ */
+async function getConversationMessages(conversationId) {
+    const db = await getDb();
+    if (!db)
+        return [];
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const messages = await sqliteDb.select()
+        .from(schema.messages)
+        .where(eq(schema.messages.conversationId, conversationId))
+        .orderBy(schema.messages.createdAt);
+    return messages.map((m) => ({
+        id: m.id,
+        conversationId: m.conversation_id,
+        role: m.role,
+        content: m.content,
+        createdAt: new Date(m.createdAt),
+    }));
+}
+/**
+ * Mark conversation as processed
+ */
+async function markConversationProcessed(conversationId) {
+    const db = await getDb();
+    if (!db)
+        return;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    await sqliteDb.update(schema.conversations)
+        .set({
+        metadata: sql `json_set(${schema.conversations.metadata}, 'selfIterationProcessed', true)`,
+    })
+        .where(eq(schema.conversations.id, conversationId));
+}
+/**
+ * Process a single conversation
+ */
+async function processConversation(conversation, config) {
+    const messages = await getConversationMessages(conversation.id);
+    let memoriesCreated = 0;
+    let summariesCreated = 0;
+    // Limit messages if configured
+    const messagesToProcess = config.maxMessagesToProcess > 0
+        ? messages.slice(-config.maxMessagesToProcess)
+        : messages;
+    if (messagesToProcess.length === 0) {
+        return { memoriesCreated, summariesCreated };
+    }
+    // Extract facts
+    if (config.extractFacts) {
+        const prompt = buildFactExtractionPrompt(messagesToProcess);
+        // Here we would call an LLM client to extract facts
+        // For now, we'll use a simple heuristic extraction
+        const extractedFacts = [];
+        for (const msg of messagesToProcess) {
+            if (msg.role === 'user') {
+                const content = msg.content.toLowerCase();
+                // Look for user preferences
+                if (content.includes('i want') || content.includes('i prefer') || content.includes('i like')) {
+                    extractedFacts.push({
+                        content: `User preference: ${msg.content}`,
+                        type: 'preference',
+                        confidence: 70,
+                    });
+                }
+                // Look for decisions
+                if (content.includes('i will') || content.includes('i decide') || content.includes('let\'s')) {
+                    extractedFacts.push({
+                        content: `Decision: ${msg.content}`,
+                        type: 'decision',
+                        confidence: 80,
+                    });
+                }
+            }
+        }
+        // Store extracted facts as memories
+        for (const fact of extractedFacts) {
+            if (fact.confidence >= 60) {
+                try {
+                    await rememberMemory({
+                        content: fact.content,
+                        type: fact.type,
+                        project: conversation.projectId,
+                        metadata: {
+                            extractionMethod: 'self-iteration',
+                            confidence: fact.confidence,
+                            conversationId: conversation.id,
+                            sessionId: conversation.sessionId,
+                        },
+                    });
+                    memoriesCreated++;
+                    logger.info(`[SelfIteration] Extracted memory: ${fact.type} - ${fact.content.substring(0, 50)}...`);
+                }
+                catch (error) {
+                    logger.error(`[SelfIteration] Failed to store memory:`, error);
+                }
+            }
+        }
+    }
+    // Generate summary
+    if (config.generateSummaries && messagesToProcess.length > 0) {
+        const prompt = buildSummaryPrompt(messagesToProcess);
+        // Here we would call an LLM client to generate summary
+        // For now, use simple heuristic
+        const userMessages = messagesToProcess.filter(m => m.role === 'user');
+        const lastMessage = userMessages[userMessages.length - 1]?.content || '';
+        const summary = lastMessage.substring(0, Math.min(250, lastMessage.length));
+        // Update conversation with summary
+        const db = await getDb();
+        const schema = await getSchema();
+        const sqliteDb = db;
+        await sqliteDb.update(schema.conversations)
+            .set({ summary })
+            .where(eq(schema.conversations.id, conversation.id));
+        summariesCreated++;
+        logger.info(`[SelfIteration] Generated summary for conversation ${conversation.sessionId}`);
+    }
+    return { memoriesCreated, summariesCreated };
+}
+/**
+ * Register self-iteration job handler
+ */
+const selfIterationHandler = async (context) => {
+    logger.info('[SelfIteration] Starting job');
+    const config = {
+        ...DEFAULT_CONFIG,
+        ...context.config,
+    };
+    if (!config.enabled) {
+        logger.info('[SelfIteration] Job disabled, skipping');
+        return { recordsProcessed: 0, summary: { status: 'disabled' } };
+    }
+    try {
+        const conversations = await getConversationsForIteration(config.maxMessagesToProcess || DEFAULT_CONFIG.maxMessagesToProcess);
+        if (conversations.length === 0) {
+            logger.info('[SelfIteration] No conversations to process');
+            return { recordsProcessed: 0, summary: { status: 'no_conversations' } };
+        }
+        let totalMemoriesCreated = 0;
+        let totalSummariesGenerated = 0;
+        let processedCount = 0;
+        for (const conversation of conversations) {
+            // Skip if already processed
+            if (conversation.metadata?.selfIterationProcessed) {
+                continue;
+            }
+            try {
+                const result = await processConversation(conversation, config);
+                totalMemoriesCreated += result.memoriesCreated;
+                totalSummariesGenerated += result.summariesCreated;
+                await markConversationProcessed(conversation.id);
+                processedCount++;
+            }
+            catch (error) {
+                logger.error(`[SelfIteration] Failed to process conversation ${conversation.id}:`, error);
+            }
+        }
+        logger.info(`[SelfIteration] Processed ${processedCount}/${conversations.length} conversations`);
+        logger.info(`[SelfIteration] Created ${totalMemoriesCreated} memories`);
+        logger.info(`[SelfIteration] Generated ${totalSummariesGenerated} summaries`);
+        return {
+            recordsProcessed: processedCount,
+            summary: {
+                memoriesCreated: totalMemoriesCreated,
+                summariesGenerated: totalSummariesGenerated,
+                totalConversations: conversations.length,
+            },
+        };
+    }
+    catch (error) {
+        logger.error('[SelfIteration] Job failed:', error);
+        return {
+            recordsProcessed: 0,
+            summary: { error: error instanceof Error ? error.message : String(error) },
+        };
+    }
+};
+export { selfIterationHandler, DEFAULT_CONFIG };
+//# sourceMappingURL=self-iteration-job.js.map

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

@@ -0,0 +1,18 @@
+/** 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/session-hooks.js

@@ -0,0 +1,58 @@
+/** 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