squish-memory 1.0.1 → 1.1.5

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

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

@@ -20,31 +20,31 @@ const DEFAULT_CONFIG = {
  */
 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:
+    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}`;
 }
 /**
@@ -52,14 +52,14 @@ ${messagesText}`;
  */
 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:
+    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}`;
 }
 /**
@@ -93,8 +93,8 @@ async function getConversationsForIteration(maxMessages) {
     // 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
+        .where(sql `${schema.conversations.endedAt} IS NOT NULL
+      AND (${schema.conversations.metadata}->>'selfIterationProcessed') IS NULL
       AND ${schema.conversations.messageCount} >= ?`)
         .limit(10);
     return conversations;

package/dist/core/{cache.js → storage/cache.js}

@@ -1,5 +1,5 @@
-import { config } from '../config.js';
-import { logger } from './logger.js';
+import { config } from '../../config.js';
+import { logger } from '../logger.js';
 let redis = null;
 class LRUCache {
     cache = new Map();

package/dist/core/sync/qmd-sync.d.ts

@@ -1,18 +1,6 @@
 /**
  * QMD Memory Synchronization
- *
- * Syncs Squish memories to QMD collections for hybrid search.
- * Writes memories as markdown files to QMD collection directories.
- *
- * QMD automatically indexes files in collection directories, so we just
- * need to write files to the right location.
- *
- * Collection Structure:
- * - qmd-collections/squish-observations/ - Observation memories
- * - qmd-collections/squish-facts/ - Fact memories
- * - qmd-collections/squish-decisions/ - Decision memories
- * - qmd-collections/squish-context/ - Context memories
- * - qmd-collections/squish-preferences/ - Preference memories
+ * Syncs Squish memories to QMD collections for hybrid search
  */
 import type { MemoryRecord } from '../memory/memories.js';
 export interface CollectionMapping {

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

@@ -1,18 +1,6 @@
 /**
  * QMD Memory Synchronization
- *
- * Syncs Squish memories to QMD collections for hybrid search.
- * Writes memories as markdown files to QMD collection directories.
- *
- * QMD automatically indexes files in collection directories, so we just
- * need to write files to the right location.
- *
- * Collection Structure:
- * - qmd-collections/squish-observations/ - Observation memories
- * - qmd-collections/squish-facts/ - Fact memories
- * - qmd-collections/squish-decisions/ - Decision memories
- * - qmd-collections/squish-context/ - Context memories
- * - qmd-collections/squish-preferences/ - Preference memories
+ * Syncs Squish memories to QMD collections for hybrid search
  */
 import { mkdir, writeFile } from 'fs/promises';
 import { join } from 'path';

package/dist/core/toon.d.ts

@@ -0,0 +1,43 @@
+/**
+ * TOON Compression - Token-efficient memory format
+ *
+ * Compact format for memory context using abbreviated notation.
+ * Achieves efficient token usage for context injection.
+ *
+ * Format:
+ * {
+ *   m:[type],      // memory type (1-2 chars)
+ *   c:"...",       // content (truncated)
+ *   t:[],          // tags (array)
+ *   d:123          // days ago
+ * }
+ */
+/**
+ * Compress a memory to TOON format
+ */
+export declare function compressForContext(content: string): string;
+/**
+ * Decompress TOON back to readable format
+ */
+export declare function decompressFromContext(toonString: string): string;
+/**
+ * Estimate compression ratio
+ */
+export declare function estimateCompressionRatio(content: string): number;
+/**
+ * Check if content is JSON
+ */
+export declare function isJson(content: string): boolean;
+/**
+ * Check if content is TOON format
+ */
+export declare function isToon(content: string): boolean;
+/**
+ * Count tokens (rough estimate)
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Truncate to token budget
+ */
+export declare function truncateToTokenBudget(content: string, maxTokens: number): string;
+//# sourceMappingURL=toon.d.ts.map