squish-memory 1.1.5 → 1.2.0

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

@@ -1,282 +0,0 @@
-/** 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-hooks/session-hooks.d.ts

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

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

@@ -1,29 +0,0 @@
-export interface MemoryDiff {
-    added?: string[];
-    removed?: string[];
-    changed?: Record<string, {
-        from: unknown;
-        to: unknown;
-    }>;
-}
-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>;
-export declare function getMemoryHistory(memoryId: string, limit?: number): Promise<any[]>;
-export declare function getMemorySnapshot(snapshotId: string): Promise<any>;
-export declare function deleteOldSnapshots(olderThanDays?: number): Promise<number>;
-export declare function compareSnapshots(snapshotId1: string, snapshotId2: string): Promise<{
-    diff: MemoryDiff;
-    contextBefore: string;
-    contextAfter: string;
-}>;
-export declare function getSnapshotStats(memoryId?: string): Promise<{
-    totalSnapshots: number;
-    byType: Record<string, number>;
-    oldestSnapshot: Date | null;
-    newestSnapshot: Date | null;
-}>;
-//# sourceMappingURL=snapshots.d.ts.map

package/dist/core/snapshots.js

@@ -1,220 +0,0 @@
-// Memory Snapshots for Auditability & Diffs
-import { eq, desc } from 'drizzle-orm';
-import { randomUUID } from 'crypto';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { cleanupOldMemorySnapshots } from './utils/cleanup-operations.js';
-import { logger } from './logger.js';
-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;
-    }
-}
-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;
-    }
-}
-export async function deleteOldSnapshots(olderThanDays = 90) {
-    return cleanupOldMemorySnapshots(olderThanDays);
-}
-function extractMetadata(memory) {
-    return {
-        type: memory.type,
-        sector: memory.sector,
-        confidence: memory.confidence,
-        relevanceScore: memory.relevanceScore,
-        tags: memory.tags,
-        agentId: memory.agentId,
-    };
-}
-function calculateDiff(before, after) {
-    const beforeLines = before.split('\n');
-    const afterLines = 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));
-    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;
-    }
-}
-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=snapshots.js.map

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

@@ -1,94 +0,0 @@
-/**
- * QMD Memory Synchronization
- * Syncs Squish memories to QMD collections for hybrid search
- */
-import type { MemoryRecord } from '../memory/memories.js';
-export interface CollectionMapping {
-    [memoryType: string]: string;
-}
-/**
- * QMD Memory Sync class
- *
- * Manages synchronization of Squish memories to QMD collections.
- */
-export declare class QMDMemorySync {
-    private collectionsPath;
-    private client;
-    private initialized;
-    constructor();
-    /**
-     * Initialize the sync layer
-     *
-     * Creates collection directories and verifies QMD connection.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Sync a memory to QMD
-     *
-     * Writes memory as markdown to the appropriate collection directory.
-     * QMD will automatically index the file on its next update cycle.
-     *
-     * @param memory - Memory record to sync
-     */
-    syncMemory(memory: MemoryRecord): Promise<void>;
-    /**
-     * Batch sync multiple memories
-     *
-     * @param memories - Array of memory records to sync
-     */
-    syncMemories(memories: MemoryRecord[]): Promise<void>;
-    /**
-     * Trigger QMD re-index
-     *
-     * Note: This would typically call `qmd update` or `qmd embed`.
-     * For now, we just log that documents are ready for indexing.
-     */
-    reindex(): Promise<void>;
-    /**
-     * Get collection name for a memory
-     *
-     * @param memory - Memory record
-     * @returns QMD collection name
-     */
-    private getCollectionForMemory;
-    /**
-     * Generate filename for memory
-     *
-     * Uses a docid-like format (6-char hash) for consistent naming.
-     *
-     * @param memory - Memory record
-     * @returns Filename for the memory
-     */
-    private getFilenameForMemory;
-    /**
-     * Format memory as markdown for QMD indexing
-     *
-     * Uses frontmatter for metadata and standard markdown for content.
-     *
-     * @param memory - Memory record
-     * @returns Markdown formatted string
-     */
-    private formatMemoryAsMarkdown;
-    /**
-     * Capitalize first letter of a string
-     */
-    private capitalize;
-    /**
-     * Create a QMD collection directory
-     *
-     * @param name - Collection name
-     */
-    private createCollection;
-}
-/**
- * Get the singleton QMD memory sync instance
- *
- * @returns QMDMemorySync instance
- */
-export declare function getQMDMemorySync(): Promise<QMDMemorySync>;
-/**
- * Reset the singleton sync instance
- * Useful for testing or when configuration changes.
- */
-export declare function resetQMDMemorySync(): void;
-//# sourceMappingURL=qmd-sync.d.ts.map