squish-memory 1.0.2 → 1.2.0

package/dist/core/memory/memory-lifecycle.js

@@ -0,0 +1,47 @@
+import { getDb } from '../../db/index.js';
+import { memories } from '../../db/drizzle/schema.js';
+import { eq } from 'drizzle-orm';
+import { logger } from '../logger.js';
+/** Promote a memory to a higher tier (cold -> hot only, simplified from warm hierarchy) */
+export async function promoteTier(memoryId) {
+    const db = await getDb();
+    // @ts-ignore - drizzle overloads
+    const row = await db.select().from(memories).where(eq(memories.id, memoryId)).limit(1);
+    const mem = row[0];
+    if (!mem)
+        return;
+    // Simplified: cold -> hot (no warm tier)
+    if (mem.tier === 'cold') {
+        await db.update(memories).set({ tier: 'hot' }).where(eq(memories.id, memoryId));
+    }
+}
+/** Demote a memory tier or expire it based on decay (simplified: hot -> cold only) */
+export async function demoteTier(memoryId) {
+    const db = await getDb();
+    // @ts-ignore
+    const row = await db.select().from(memories).where(eq(memories.id, memoryId)).limit(1);
+    const mem = row[0];
+    if (!mem)
+        return;
+    // Simplified: hot -> cold (no warm tier)
+    if (mem.tier === 'hot') {
+        await db.update(memories).set({ tier: 'cold' }).where(eq(memories.id, memoryId));
+    }
+}
+export async function expireMemory(memoryId) {
+    const db = await getDb();
+    // @ts-ignore
+    await db.update(memories).set({ status: 'expired' }).where(eq(memories.id, memoryId));
+}
+export async function markMerged(memoryId, targetId) {
+    const db = await getDb();
+    // @ts-ignore
+    await db.update(memories).set({ is_merged: true, merged_into_id: targetId }).where(eq(memories.id, memoryId));
+}
+export async function markSuperseded(memoryId) {
+    const db = await getDb();
+    // @ts-ignore
+    await db.update(memories).set({ is_merged: true }).where(eq(memories.id, memoryId));
+}
+logger.info('Memory lifecycle helpers loaded');
+//# sourceMappingURL=memory-lifecycle.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * Memory Migration Module
+ * Migrate memories between .squish directories/databases
+ */
+export interface MigrateOptions {
+    dryRun?: boolean;
+    deleteSource?: boolean;
+}
+export interface MigrateResult {
+    memoriesCopied: number;
+    observationsCopied: number;
+    associationsCopied: number;
+    projectsMapped: number;
+    sourceDeleted?: boolean;
+    message: string;
+}
+/**
+ * Migrate memories from one .squish directory to another
+ */
+export declare function migrateMemories(sourceDir: string, targetDir: string, options?: MigrateOptions): Promise<MigrateResult>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/core/memory/migrate.js

@@ -0,0 +1,134 @@
+/**
+ * Memory Migration Module
+ * Migrate memories between .squish directories/databases
+ */
+import { randomUUID } from 'crypto';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getDbClient } from '../lib/db-client.js';
+/**
+ * Migrate memories from one .squish directory to another
+ */
+export async function migrateMemories(sourceDir, targetDir, options = {}) {
+    const { dryRun = false, deleteSource = false } = options;
+    const sourceDbPath = join(sourceDir, 'squish.db');
+    const targetDbPath = join(targetDir, 'squish.db');
+    if (!existsSync(sourceDbPath)) {
+        throw new Error(`Source database not found: ${sourceDbPath}`);
+    }
+    if (!existsSync(targetDbPath)) {
+        throw new Error(`Target database not found: ${targetDbPath}`);
+    }
+    // Use bun:sqlite for direct source DB access
+    // @ts-ignore - bun:sqlite module not found in types but works at runtime
+    const SqliteDatabase = (await import('bun:sqlite')).default;
+    const sourceDb = new SqliteDatabase(sourceDbPath, { readonly: true });
+    // Get target DB through the app's existing mechanism
+    const { db: targetDb, schema } = await getDbClient();
+    // Get all projects from source
+    const sourceProjects = sourceDb.query('SELECT * FROM projects').all();
+    // Map old project IDs to new project IDs
+    const projectIdMap = new Map();
+    for (const project of sourceProjects) {
+        // Check if project with same path exists in target
+        const existing = await targetDb.select()
+            .from(schema.projects)
+            .where((tbl, { eq }) => eq(tbl.path, project.path))
+            .limit(1);
+        if (existing.length > 0) {
+            projectIdMap.set(project.id, existing[0].id);
+        }
+        else {
+            // Create new project in target
+            const newId = randomUUID();
+            await targetDb.insert(schema.projects).values({
+                id: newId,
+                path: project.path,
+                name: project.name || 'migrated',
+                createdAt: new Date(),
+            });
+            projectIdMap.set(project.id, newId);
+        }
+    }
+    // Migrate memories
+    const sourceMemories = sourceDb.query('SELECT * FROM memories').all();
+    let memoriesCopied = 0;
+    for (const mem of sourceMemories) {
+        const oldProjectId = mem.project_id;
+        const newProjectId = projectIdMap.get(oldProjectId);
+        if (!newProjectId) {
+            console.warn(`Skipping memory ${mem.id}: no project mapping found`);
+            continue;
+        }
+        if (!dryRun) {
+            // Add 'imported' tag to track migrated memories
+            const existingTags = mem.tags ? JSON.parse(mem.tags) : [];
+            const newTags = [...existingTags, 'imported'];
+            await targetDb.insert(schema.memories).values({
+                id: randomUUID(),
+                projectId: newProjectId,
+                type: mem.type,
+                content: mem.content,
+                summary: mem.summary,
+                source: mem.source || 'migrated',
+                confidence: mem.confidence ?? 50,
+                confidenceLevel: mem.confidence_level || 'speculative',
+                tags: newTags,
+                metadata: { ...mem.metadata, migratedAt: new Date().toISOString(), originalId: mem.id },
+                isActive: mem.is_active ?? 1,
+                createdAt: mem.created_at ? new Date(mem.created_at * 1000) : new Date(),
+                updatedAt: new Date(),
+            });
+        }
+        memoriesCopied++;
+    }
+    // Migrate learnings (renamed from observations)
+    const sourceLearnings = sourceDb.query('SELECT * FROM learnings').all();
+    let learningsCopied = 0;
+    for (const learn of sourceLearnings) {
+        const oldProjectId = learn.project_id;
+        const newProjectId = projectIdMap.get(oldProjectId);
+        if (!newProjectId)
+            continue;
+        if (!dryRun) {
+            // Add is_imported flag to track migrated learnings
+            await targetDb.insert(schema.learnings).values({
+                id: randomUUID(),
+                projectId: newProjectId,
+                type: learn.type,
+                action: learn.action,
+                summary: learn.summary,
+                target: learn.target,
+                details: learn.details,
+                isImported: true,
+                createdAt: new Date(),
+            });
+        }
+        learningsCopied++;
+    }
+    // Migrate memory associations (simplified - skip for now)
+    const sourceAssoc = sourceDb.query('SELECT * FROM memory_associations').all();
+    let associationsCopied = 0;
+    if (!dryRun && sourceAssoc.length > 0) {
+        console.warn(`Note: ${sourceAssoc.length} associations not migrated (requires ID mapping)`);
+    }
+    // Close source DB
+    sourceDb.close();
+    // Delete source if requested
+    let sourceDeleted = false;
+    if (!dryRun && deleteSource && memoriesCopied > 0) {
+        // Implementation would delete the file
+        console.warn('Source deletion not implemented - requires manual removal');
+    }
+    return {
+        memoriesCopied,
+        observationsCopied: learningsCopied,
+        associationsCopied,
+        projectsMapped: projectIdMap.size,
+        sourceDeleted,
+        message: dryRun
+            ? 'Dry run complete - no changes made'
+            : `Successfully migrated ${memoriesCopied} memories, ${learningsCopied} learnings`
+    };
+}
+//# sourceMappingURL=migrate.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * Memory normalization utilities
+ * Shared between memories.ts and loader.ts to avoid circular dependencies
+ */
+import type { MemoryRecord } from '../lib/types.js';
+export declare function normalizeMemory(row: any): MemoryRecord;
+//# sourceMappingURL=normalization.d.ts.map

package/dist/core/memory/normalization.js

@@ -0,0 +1,26 @@
+/**
+ * Memory normalization utilities
+ * Shared between memories.ts and loader.ts to avoid circular dependencies
+ */
+import { deserializeTags, deserializeMetadata } from './serialization.js';
+import { normalizeTimestamp } from '../lib/utils.js';
+export function normalizeMemory(row) {
+    const tags = deserializeTags(row.tags ?? null);
+    const metadata = deserializeMetadata(row.metadata ?? null);
+    const createdAtStr = normalizeTimestamp(row.createdAt ?? row.created_at);
+    return {
+        id: row.id,
+        projectId: row.projectId ?? row.project_id ?? null,
+        type: row.type,
+        content: row.content,
+        summary: row.summary ?? null,
+        tags,
+        metadata,
+        createdAt: createdAtStr,
+        validFrom: row.validFrom ?? row.valid_from ?? null,
+        validTo: row.validTo ?? row.valid_to ?? null,
+        recordedAt: row.recordedAt ?? row.recorded_at ?? null,
+        confidenceLevel: row.confidenceLevel ?? row.confidence_level ?? null,
+    };
+}
+//# sourceMappingURL=normalization.js.map

package/dist/core/memory/path-strengthener.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Path Strengthener
+ *
+ * Strengthens association paths that led to successful retrievals and
+ * weakens paths that led to irrelevant results. This implements the
+ * "optimize" concept: the graph develops its own sense of relevance
+ * over time based on actual usage patterns.
+ *
+ * A customer support agent's graph naturally strengthens paths through
+ * product docs and refund policies while letting rarely-queried HR
+ * edges decay.
+ */
+export interface PathStrengthResult {
+    strengthened: number;
+    weakened: number;
+    pruned: number;
+}
+/**
+ * Strengthen the association path between memories that were
+ * retrieved together and found useful.
+ */
+export declare function strengthenPath(memoryIds: string[], boostAmount?: number): Promise<number>;
+/**
+ * Weaken association paths that led to irrelevant results.
+ */
+export declare function weakenPath(memoryIds: string[], decayAmount?: number): Promise<number>;
+/**
+ * Prune associations that have decayed below a threshold.
+ */
+export declare function pruneWeakAssociations(minWeight?: number, maxAge?: number): Promise<number>;
+/**
+ * Run a full optimize cycle: strengthen useful paths, weaken unused ones,
+ * prune dead associations, and derive implicit facts.
+ */
+export declare function runPruneCycle(options?: {
+    minWeight?: number;
+    maxAge?: number;
+}): Promise<PathStrengthResult>;
+//# sourceMappingURL=path-strengthener.d.ts.map

package/dist/core/memory/path-strengthener.js

@@ -0,0 +1,150 @@
+/**
+ * Path Strengthener
+ *
+ * Strengthens association paths that led to successful retrievals and
+ * weakens paths that led to irrelevant results. This implements the
+ * "optimize" concept: the graph develops its own sense of relevance
+ * over time based on actual usage patterns.
+ *
+ * A customer support agent's graph naturally strengthens paths through
+ * product docs and refund policies while letting rarely-queried HR
+ * edges decay.
+ */
+import { eq, and, or, sql } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+/**
+ * Strengthen the association path between memories that were
+ * retrieved together and found useful.
+ */
+export async function strengthenPath(memoryIds, boostAmount = 2) {
+    if (memoryIds.length < 2)
+        return 0;
+    const db = await getDb();
+    const schema = await getSchema();
+    let strengthened = 0;
+    // Generate all pairs
+    for (let i = 0; i < memoryIds.length; i++) {
+        for (let j = i + 1; j < memoryIds.length; j++) {
+            try {
+                // Check if association exists
+                const existing = await db
+                    .select()
+                    .from(schema.memoryAssociations)
+                    .where(or(and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[i]), eq(schema.memoryAssociations.toMemoryId, memoryIds[j])), and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[j]), eq(schema.memoryAssociations.toMemoryId, memoryIds[i]))))
+                    .limit(1);
+                if (existing.length > 0) {
+                    // Strengthen existing association
+                    await db
+                        .update(schema.memoryAssociations)
+                        .set({
+                        weight: sql `${schema.memoryAssociations.weight} + ${boostAmount}`,
+                        coactivationCount: sql `${schema.memoryAssociations.coactivationCount} + 1`,
+                        lastCoactivatedAt: new Date(),
+                    })
+                        .where(eq(schema.memoryAssociations.id, existing[0].id));
+                }
+                else {
+                    // Create new association
+                    await db.insert(schema.memoryAssociations).values({
+                        fromMemoryId: memoryIds[i],
+                        toMemoryId: memoryIds[j],
+                        associationType: 'co_occurred',
+                        weight: boostAmount,
+                        coactivationCount: 1,
+                        lastCoactivatedAt: new Date(),
+                    });
+                }
+                strengthened++;
+            }
+            catch (error) {
+                logger.debug('Error strengthening path', {
+                    from: memoryIds[i],
+                    to: memoryIds[j],
+                    error: error,
+                });
+            }
+        }
+    }
+    return strengthened;
+}
+/**
+ * Weaken association paths that led to irrelevant results.
+ */
+export async function weakenPath(memoryIds, decayAmount = 0.5) {
+    if (memoryIds.length < 2)
+        return 0;
+    const db = await getDb();
+    const schema = await getSchema();
+    let weakened = 0;
+    for (let i = 0; i < memoryIds.length; i++) {
+        for (let j = i + 1; j < memoryIds.length; j++) {
+            try {
+                const existing = await db
+                    .select()
+                    .from(schema.memoryAssociations)
+                    .where(or(and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[i]), eq(schema.memoryAssociations.toMemoryId, memoryIds[j])), and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[j]), eq(schema.memoryAssociations.toMemoryId, memoryIds[i]))))
+                    .limit(1);
+                if (existing.length > 0) {
+                    // Weaken but don't remove (minimum weight of 1)
+                    await db
+                        .update(schema.memoryAssociations)
+                        .set({
+                        weight: sql `GREATEST(${schema.memoryAssociations.weight} - ${decayAmount}, 1)`,
+                    })
+                        .where(eq(schema.memoryAssociations.id, existing[0].id));
+                    weakened++;
+                }
+            }
+            catch (error) {
+                logger.debug('Error weakening path', {
+                    from: memoryIds[i],
+                    to: memoryIds[j],
+                    error: error,
+                });
+            }
+        }
+    }
+    return weakened;
+}
+/**
+ * Prune associations that have decayed below a threshold.
+ */
+export async function pruneWeakAssociations(minWeight = 2, maxAge = 90 // days
+) {
+    const db = await getDb();
+    const schema = await getSchema();
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - maxAge);
+    try {
+        // Delete associations that are weak AND old
+        const result = await db
+            .delete(schema.memoryAssociations)
+            .where(and(sql `${schema.memoryAssociations.weight} < ${minWeight}`, sql `${schema.memoryAssociations.lastCoactivatedAt} < ${cutoffDate}`));
+        const pruned = result?.rowCount ?? 0;
+        logger.info('Pruned weak associations', { pruned, minWeight, maxAge });
+        return pruned;
+    }
+    catch (error) {
+        logger.error('Error pruning weak associations', { error: error });
+        return 0;
+    }
+}
+/**
+ * Run a full optimize cycle: strengthen useful paths, weaken unused ones,
+ * prune dead associations, and derive implicit facts.
+ */
+export async function runPruneCycle(options) {
+    const { minWeight = 2, maxAge = 90 } = options || {};
+    logger.info('Starting prune cycle', { minWeight, maxAge });
+    // Step 1: Prune weak associations
+    const pruned = await pruneWeakAssociations(minWeight, maxAge);
+    logger.info('Prune cycle completed', { pruned });
+    return {
+        strengthened: 0, // Strengthening happens via retrieval feedback
+        weakened: 0, // Weakening happens via retrieval feedback
+        pruned,
+    };
+}
+//# sourceMappingURL=path-strengthener.js.map

package/dist/core/memory/progressive-disclosure.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'crypto';
 import { eq, desc, and, sql } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { createDatabaseClient } from '../storage/database.js';
 const PREVIEW_TOKENS = 50;
 const MAX_PRELOAD_CANDIDATES = 20;
 const TOKEN_ESTIMATE_CHARS = 4;

package/dist/core/memory/query-processor.js

@@ -36,9 +36,43 @@ export function expandQuery(query) {
             }
         }
     }
-    // Extract simple entities (capitalized words)
-    const entityMatches = query.match(/\b[A-Z][a-z]+\b/g);
-    const entities = entityMatches ? [...new Set(entityMatches)] : [];
+    // Extract entities (capitalized words), filtering common stopwords
+    const STOP_WORDS = new Set([
+        'The', 'A', 'An', 'This', 'That', 'These', 'Those',
+        'I', 'You', 'We', 'They', 'He', 'She', 'It',
+        'What', 'When', 'Where', 'Why', 'How',
+        'My', 'Your', 'Our', 'Their', 'Its',
+        'If', 'But', 'Or', 'And', 'So', 'Then',
+        'Just', 'Only', 'Also', 'Very', 'Too',
+        'Has', 'Have', 'Had', 'Does', 'Did', 'Will', 'Would', 'Could', 'Should',
+        'Can', 'May', 'Might', 'Must', 'Shall',
+        'With', 'Without', 'From', 'Into', 'About', 'After', 'Before', 'Between',
+        'During', 'Through', 'Under', 'Over', 'Above', 'Below',
+        'All', 'Some', 'Any', 'No', 'Not', 'Each', 'Every', 'Most', 'Many', 'Much',
+        'Few', 'Both', 'Either', 'Neither', 'Another', 'Other',
+        'Such', 'Same', 'Different', 'New', 'Old', 'First', 'Last', 'Next', 'Last',
+        'See', 'Get', 'Make', 'Do', 'Say', 'Tell', 'Know', 'Think', 'Want', 'Use',
+        'Find', 'Give', 'Take', 'Show', 'Send', 'Put', 'Keep', 'Let', 'Begin', 'Seem',
+    ]);
+    // Common tech stack terms that ARE entities (preserves known entities)
+    const TECH_TERMS = new Set([
+        'TypeScript', 'JavaScript', 'Python', 'Java', 'Go', 'Rust', 'Ruby', 'PHP',
+        'React', 'Vue', 'Angular', 'Svelte', 'Next', 'Nuxt', 'Astro',
+        'Node', 'Express', 'Fastify', 'Deno', 'Bun',
+        'PostgreSQL', 'MySQL', 'MongoDB', 'Redis', 'SQLite', 'DynamoDB',
+        'AWS', 'GCP', 'Azure', 'Docker', 'Kubernetes', 'Terraform',
+        'OpenAI', 'Anthropic', 'Google', 'Meta', 'Microsoft', 'Apple',
+        'HTML', 'CSS', 'Tailwind', 'GraphQL', 'REST', 'gRPC', 'WebSocket',
+        'CI', 'CD', 'Git', 'GitHub', 'GitLab', 'Bitbucket',
+    ]);
+    const entityMatches = query.match(/\b[A-Z][a-z]{2,}\b/g) || [];
+    const entities = [...new Set(entityMatches)].filter(e => {
+        // Always include known tech terms
+        if (TECH_TERMS.has(e))
+            return true;
+        // Filter out stopwords
+        return !STOP_WORDS.has(e);
+    });
     return {
         original: query,
         expanded: [...new Set(expanded)], // Deduplicate

package/dist/core/memory/query-rewriter.js

@@ -2,15 +2,15 @@
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
 import { expandQuery } from './query-processor.js';
-const REWRITE_SYSTEM_PROMPT = `You are a search query optimizer. Given a conversation context and a user's latest message, rewrite the message into the single most effective search query to retrieve relevant memories.
-
-Rules:
-1. Output ONLY the optimized search query - no explanations or extra text
-2. Remove filler words (please, can you, etc.)
-3. Focus on the core information need
-4. Preserve important entities (names, dates, technical terms)
-5. Add synonyms for key terms if helpful
-6. Consider what memories would be most relevant
+const REWRITE_SYSTEM_PROMPT = `You are a search query optimizer. Given a conversation context and a user's latest message, rewrite the message into the single most effective search query to retrieve relevant memories.
+
+Rules:
+1. Output ONLY the optimized search query - no explanations or extra text
+2. Remove filler words (please, can you, etc.)
+3. Focus on the core information need
+4. Preserve important entities (names, dates, technical terms)
+5. Add synonyms for key terms if helpful
+6. Consider what memories would be most relevant
 7. If the message is about recalling something specific, include those details`;
 export async function rewriteQuery(query, context) {
     if (!config.queryRewritingEnabled) {

package/dist/core/memory/retrieval-feedback.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Retrieval Feedback System
+ *
+ * Tracks whether retrieved memories were useful in responses.
+ * Strengthens useful paths, prunes stale nodes, tunes edge weights.
+ */
+export interface RetrievalFeedback {
+    memoryId: string;
+    query: string;
+    wasUseful: boolean;
+    cited: boolean;
+    responseId?: string;
+    timestamp: Date;
+}
+export interface FeedbackStats {
+    totalRetrievals: number;
+    usefulRetrievals: number;
+    citedRetrievals: number;
+    usefulnessRate: number;
+    citationRate: number;
+}
+/**
+ * Record that a memory was retrieved for a query.
+ * Call this when a memory appears in search results.
+ */
+export declare function recordRetrieval(memoryId: string, query: string, options?: {
+    sessionId?: string;
+}): void;
+/**
+ * Record that a retrieved memory was actually useful.
+ * Call this when a memory is cited or referenced in a response.
+ */
+export declare function recordUsefulRetrieval(memoryId: string, query: string, options?: {
+    cited?: boolean;
+    responseId?: string;
+    sessionId?: string;
+}): void;
+/**
+ * Record that a memory was cited in a response.
+ * This is stronger feedback than just "useful" - it means the memory
+ * was explicitly referenced.
+ */
+export declare function recordCitation(memoryId: string, responseId: string, options?: {
+    sessionId?: string;
+}): void;
+/**
+ * Get feedback statistics for a specific memory.
+ */
+export declare function getRetrievalStats(memoryId: string): FeedbackStats;
+/**
+ * Get overall feedback statistics.
+ */
+export declare function getOverallFeedbackStats(): FeedbackStats;
+/**
+ * Flush feedback to the database, updating association weights.
+ */
+export declare function flushFeedback(): Promise<{
+    strengthened: number;
+    weakened: number;
+    total: number;
+}>;
+/**
+ * Start the periodic feedback flush timer.
+ */
+export declare function startFeedbackFlushTimer(): void;
+/**
+ * Stop the periodic feedback flush timer.
+ */
+export declare function stopFeedbackFlushTimer(): void;
+//# sourceMappingURL=retrieval-feedback.d.ts.map