squish-memory 1.0.2 → 1.2.0

package/dist/core/memory/retrieval-feedback.js

@@ -0,0 +1,213 @@
+/**
+ * Retrieval Feedback System
+ *
+ * Tracks whether retrieved memories were useful in responses.
+ * Strengthens useful paths, prunes stale nodes, tunes edge weights.
+ */
+import { eq, sql } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+// ─── In-Memory Feedback Buffer ───────────────────────────────────────────────
+const feedbackBuffer = new Map();
+const MAX_BUFFER_SIZE = 1000;
+const FLUSH_INTERVAL_MS = 60000; // 1 minute
+let flushTimer = null;
+/**
+ * Record that a memory was retrieved for a query.
+ * Call this when a memory appears in search results.
+ */
+export function recordRetrieval(memoryId, query, options) {
+    const key = options?.sessionId || 'default';
+    const buffer = feedbackBuffer.get(key) || [];
+    buffer.push({
+        memoryId,
+        query,
+        wasUseful: false, // Will be updated later
+        cited: false,
+        timestamp: new Date(),
+    });
+    // Trim buffer if too large
+    if (buffer.length > MAX_BUFFER_SIZE) {
+        buffer.splice(0, buffer.length - MAX_BUFFER_SIZE);
+    }
+    feedbackBuffer.set(key, buffer);
+}
+/**
+ * Record that a retrieved memory was actually useful.
+ * Call this when a memory is cited or referenced in a response.
+ */
+export function recordUsefulRetrieval(memoryId, query, options) {
+    const key = options?.sessionId || 'default';
+    const buffer = feedbackBuffer.get(key) || [];
+    // Find the existing retrieval record and update it
+    const existing = buffer.find(f => f.memoryId === memoryId && f.query === query && !f.wasUseful);
+    if (existing) {
+        existing.wasUseful = true;
+        existing.cited = options?.cited ?? false;
+        existing.responseId = options?.responseId;
+    }
+    else {
+        // Add a new record
+        buffer.push({
+            memoryId,
+            query,
+            wasUseful: true,
+            cited: options?.cited ?? false,
+            responseId: options?.responseId,
+            timestamp: new Date(),
+        });
+    }
+    feedbackBuffer.set(key, buffer);
+}
+/**
+ * Record that a memory was cited in a response.
+ * This is stronger feedback than just "useful" - it means the memory
+ * was explicitly referenced.
+ */
+export function recordCitation(memoryId, responseId, options) {
+    const key = options?.sessionId || 'default';
+    const buffer = feedbackBuffer.get(key) || [];
+    // Mark all retrievals of this memory as useful
+    for (const feedback of buffer) {
+        if (feedback.memoryId === memoryId) {
+            feedback.wasUseful = true;
+            feedback.cited = true;
+            feedback.responseId = responseId;
+        }
+    }
+    feedbackBuffer.set(key, buffer);
+}
+/**
+ * Get feedback statistics for a specific memory.
+ */
+export function getRetrievalStats(memoryId) {
+    let totalRetrievals = 0;
+    let usefulRetrievals = 0;
+    let citedRetrievals = 0;
+    for (const [, buffer] of feedbackBuffer) {
+        for (const feedback of buffer) {
+            if (feedback.memoryId === memoryId) {
+                totalRetrievals++;
+                if (feedback.wasUseful)
+                    usefulRetrievals++;
+                if (feedback.cited)
+                    citedRetrievals++;
+            }
+        }
+    }
+    return {
+        totalRetrievals,
+        usefulRetrievals,
+        citedRetrievals,
+        usefulnessRate: totalRetrievals > 0 ? usefulRetrievals / totalRetrievals : 0,
+        citationRate: totalRetrievals > 0 ? citedRetrievals / totalRetrievals : 0,
+    };
+}
+/**
+ * Get overall feedback statistics.
+ */
+export function getOverallFeedbackStats() {
+    let totalRetrievals = 0;
+    let usefulRetrievals = 0;
+    let citedRetrievals = 0;
+    for (const [, buffer] of feedbackBuffer) {
+        for (const feedback of buffer) {
+            totalRetrievals++;
+            if (feedback.wasUseful)
+                usefulRetrievals++;
+            if (feedback.cited)
+                citedRetrievals++;
+        }
+    }
+    return {
+        totalRetrievals,
+        usefulRetrievals,
+        citedRetrievals,
+        usefulnessRate: totalRetrievals > 0 ? usefulRetrievals / totalRetrievals : 0,
+        citationRate: totalRetrievals > 0 ? citedRetrievals / totalRetrievals : 0,
+    };
+}
+/**
+ * Flush feedback to the database, updating association weights.
+ */
+export async function flushFeedback() {
+    const db = await getDb();
+    const schema = await getSchema();
+    let strengthened = 0;
+    let weakened = 0;
+    let total = 0;
+    for (const [, buffer] of feedbackBuffer) {
+        for (const feedback of buffer) {
+            total++;
+            try {
+                // Get associations involving this memory
+                const associations = await db
+                    .select()
+                    .from(schema.memoryAssociations)
+                    .where(sql `${schema.memoryAssociations.fromMemoryId} = ${feedback.memoryId} OR ${schema.memoryAssociations.toMemoryId} = ${feedback.memoryId}`);
+                for (const assoc of associations) {
+                    if (feedback.wasUseful) {
+                        // Strengthen: increase weight and coactivation count
+                        await db
+                            .update(schema.memoryAssociations)
+                            .set({
+                            weight: sql `${schema.memoryAssociations.weight} + 1`,
+                            coactivationCount: sql `${schema.memoryAssociations.coactivationCount} + 1`,
+                            lastCoactivatedAt: new Date(),
+                        })
+                            .where(eq(schema.memoryAssociations.id, assoc.id));
+                        strengthened++;
+                    }
+                    else {
+                        // Weaken: decrease weight slightly (but don't go below 1)
+                        await db
+                            .update(schema.memoryAssociations)
+                            .set({
+                            weight: sql `GREATEST(${schema.memoryAssociations.weight} - 0.5, 1)`,
+                        })
+                            .where(eq(schema.memoryAssociations.id, assoc.id));
+                        weakened++;
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug('Error updating association weights', {
+                    memoryId: feedback.memoryId,
+                    error: error,
+                });
+            }
+        }
+    }
+    // Clear the buffer after flushing
+    feedbackBuffer.clear();
+    logger.info('Feedback flushed', { strengthened, weakened, total });
+    return { strengthened, weakened, total };
+}
+/**
+ * Start the periodic feedback flush timer.
+ */
+export function startFeedbackFlushTimer() {
+    if (flushTimer)
+        return;
+    flushTimer = setInterval(async () => {
+        try {
+            await flushFeedback();
+        }
+        catch (error) {
+            logger.error('Error flushing feedback', { error: error });
+        }
+    }, FLUSH_INTERVAL_MS);
+    logger.info('Feedback flush timer started', { intervalMs: FLUSH_INTERVAL_MS });
+}
+/**
+ * Stop the periodic feedback flush timer.
+ */
+export function stopFeedbackFlushTimer() {
+    if (flushTimer) {
+        clearInterval(flushTimer);
+        flushTimer = null;
+        logger.info('Feedback flush timer stopped');
+    }
+}
+//# sourceMappingURL=retrieval-feedback.js.map

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

@@ -3,4 +3,8 @@ export declare function toSqliteJson(value: unknown): string | null;
 export declare function fromSqliteJson<T>(value: string | null | undefined): T | null;
 export declare function toSqliteTags(tags?: string[]): string | null;
 export declare function fromSqliteTags(value: string | null | undefined): string[];
+export declare function serializeTags(tags?: string[]): string[] | string | null | undefined;
+export declare function deserializeTags(value: string[] | string | null | undefined): string[];
+export declare function serializeMetadata(metadata: Record<string, unknown> | null | undefined): Record<string, unknown> | string | null;
+export declare function deserializeMetadata(value: Record<string, unknown> | string | null | undefined): Record<string, unknown> | null;
 //# sourceMappingURL=serialization.d.ts.map

package/dist/core/memory/serialization.js

@@ -1,3 +1,4 @@
+import { config } from '../../config.js';
 export function normalizeTags(tags) {
     return (tags || []).map((tag) => tag.trim()).filter((tag) => tag.length > 0);
 }
@@ -32,4 +33,52 @@ export function fromSqliteTags(value) {
         return value.split(',').map((tag) => tag.trim()).filter(Boolean);
     }
 }
+// High-level helpers that abstract away team mode vs local mode
+export function serializeTags(tags) {
+    if (config.isTeamMode) {
+        // PostgreSQL: store as array directly (or null if empty)
+        return tags && tags.length > 0 ? tags : null;
+    }
+    else {
+        // SQLite: store as JSON string (or null)
+        return toSqliteTags(tags);
+    }
+}
+export function deserializeTags(value) {
+    if (config.isTeamMode) {
+        // PostgreSQL: value is already an array or null/undefined
+        return Array.isArray(value) ? value : [];
+    }
+    else {
+        // SQLite: value is a JSON string or null/undefined
+        if (typeof value === 'string' || value === null || value === undefined) {
+            return fromSqliteTags(value);
+        }
+        // Unexpected type, return empty array
+        return [];
+    }
+}
+export function serializeMetadata(metadata) {
+    if (config.isTeamMode) {
+        // PostgreSQL: store object directly (or null if null/undefined, keep empty object as-is)
+        return metadata === undefined || metadata === null ? null : metadata;
+    }
+    else {
+        // SQLite: store as JSON string (or null)
+        return toSqliteJson(metadata);
+    }
+}
+export function deserializeMetadata(value) {
+    if (config.isTeamMode) {
+        // PostgreSQL: value is already an object or null/undefined
+        return value == null ? null : value;
+    }
+    else {
+        // SQLite: value is a JSON string or null/undefined
+        if (typeof value === 'string' || value === null) {
+            return fromSqliteJson(value);
+        }
+        return null;
+    }
+}
 //# sourceMappingURL=serialization.js.map

package/dist/core/memory/stale-cleaner.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Stale Memory Cleaner
+ * Deletes memories that are old, low-confidence, and low-importance
+ */
+export interface StaleMemory {
+    id: string;
+    content: string;
+    type: string;
+    createdAt: Date;
+    confidenceLevel: string | null;
+    importanceScore: number | null;
+    isPinned: boolean;
+}
+export interface StaleMemoryQuery {
+    olderThanDays: number;
+    confidenceLevels: string[];
+    minImportance: number;
+    projectId?: string;
+}
+export declare function getStaleMemories(query: StaleMemoryQuery): Promise<StaleMemory[]>;
+export declare function deleteMemoryPermanently(memoryId: string): Promise<void>;
+export declare function runAutoClean(options?: Partial<StaleMemoryQuery>): Promise<{
+    deleted: number;
+    summary: Record<string, unknown>;
+}>;
+//# sourceMappingURL=stale-cleaner.d.ts.map

package/dist/core/memory/stale-cleaner.js

@@ -0,0 +1,97 @@
+/**
+ * Stale Memory Cleaner
+ * Deletes memories that are old, low-confidence, and low-importance
+ */
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { lt, or, and, eq, lte } from 'drizzle-orm';
+export async function getStaleMemories(query) {
+    const db = await getDb();
+    if (!db)
+        return [];
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const cutoffDate = new Date(Date.now() - query.olderThanDays * 24 * 60 * 60 * 1000);
+    // Build conditions
+    const conditions = [
+        // Not pinned
+        or(eq(schema.memories.isPinned, false), eq(schema.memories.isPinned, null)),
+        // Older than cutoff
+        lt(schema.memories.createdAt, cutoffDate),
+    ];
+    // Confidence level filter
+    if (query.confidenceLevels.length > 0) {
+        conditions.push(or(...query.confidenceLevels.map(level => eq(schema.memories.confidenceLevel, level))));
+    }
+    // Importance filter (below threshold)
+    conditions.push(lte(schema.memories.importanceScore, query.minImportance));
+    // Project filter if specified
+    if (query.projectId) {
+        conditions.push(eq(schema.memories.projectId, query.projectId));
+    }
+    try {
+        const results = await sqliteDb
+            .select({
+            id: schema.memories.id,
+            content: schema.memories.content,
+            type: schema.memories.type,
+            createdAt: schema.memories.createdAt,
+            confidenceLevel: schema.memories.confidenceLevel,
+            importanceScore: schema.memories.importanceScore,
+            isPinned: schema.memories.isPinned,
+        })
+            .from(schema.memories)
+            .where(and(...conditions.filter(Boolean)));
+        return results.map((r) => ({
+            ...r,
+            isPinned: Boolean(r.isPinned),
+        }));
+    }
+    catch (error) {
+        console.error('[StaleCleaner] Error querying stale memories:', error);
+        return [];
+    }
+}
+export async function deleteMemoryPermanently(memoryId) {
+    const db = await getDb();
+    if (!db)
+        return;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    try {
+        // Delete associated records first
+        await sqliteDb.delete(schema.memoryAssociations).where(or(eq(schema.memoryAssociations.fromMemoryId, memoryId), eq(schema.memoryAssociations.toMemoryId, memoryId))).catch(() => { }); // Ignore if table doesn't exist
+        // Delete memory tags
+        await sqliteDb.delete(schema.memoryTags).where(eq(schema.memoryTags.memoryId, memoryId)).catch(() => { }); // Ignore if table doesn't exist
+        // Delete the memory itself
+        await sqliteDb.delete(schema.memories).where(eq(schema.memories.id, memoryId));
+    }
+    catch (error) {
+        console.error(`[StaleCleaner] Error deleting memory ${memoryId}:`, error);
+        throw error;
+    }
+}
+export async function runAutoClean(options) {
+    const defaultOptions = {
+        olderThanDays: options?.olderThanDays || 30,
+        confidenceLevels: options?.confidenceLevels || ['outdated', 'speculative'],
+        minImportance: options?.minImportance || 40,
+    };
+    const stale = await getStaleMemories(defaultOptions);
+    let deleted = 0;
+    for (const memory of stale) {
+        if (!memory.isPinned) {
+            await deleteMemoryPermanently(memory.id);
+            deleted++;
+        }
+    }
+    return {
+        deleted,
+        summary: {
+            scanned: stale.length,
+            skippedPinned: stale.length - deleted,
+            criteria: defaultOptions,
+        },
+    };
+}
+//# sourceMappingURL=stale-cleaner.js.map

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

@@ -5,10 +5,25 @@
 export interface MemoryStats {
     totalMemories: number;
     byType: Record<string, number>;
+    totalNotes: number;
+    notesByCategory: Record<string, number>;
+    totalLearnings: number;
+    learningsByType: Record<string, number>;
+    totalLinks: number;
     oldestMemory?: string;
     newestMemory?: string;
     projectPath: string;
     mode: string;
+    signal?: {
+        captured: number;
+        suppressed: number;
+        sessionOnly: number;
+        durable: number;
+        durableWithRaw: number;
+        tokensSaved: number;
+        placeRouted: number;
+        graphEnriched: number;
+    };
 }
 /**
  * Get memory statistics for a project

package/dist/core/memory/stats.js

@@ -5,8 +5,9 @@
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
 import { config } from '../../config.js';
-import { getProjectByPath } from '../../core/projects.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { ensureProject } from '../../core/projects.js';
+import { createDatabaseClient } from '../storage/database.js';
+import { getProjectSignalStats } from '../session/working-set.js';
 /**
  * Get memory statistics for a project
  */
@@ -19,28 +20,36 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         throw new Error(`Database unavailable: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
     const schema = await getSchema();
-    const project = await getProjectByPath(projectPath);
+    const project = await ensureProject(projectPath);
+    if (!project) {
+        throw new Error(`Project not found: ${projectPath}`);
+    }
     const stats = {
         totalMemories: 0,
         byType: {},
+        totalNotes: 0,
+        notesByCategory: {},
+        totalLearnings: 0,
+        learningsByType: {},
+        totalLinks: 0,
         projectPath,
-        mode: config.isTeamMode ? 'team' : 'local'
+        mode: config.isTeamMode ? 'team' : 'local',
     };
     try {
         // Count total memories
         const countResult = await db
             .select({ count: schema.memories.id })
             .from(schema.memories)
-            .where(project ? eq(schema.memories.projectId, project.id) : undefined);
+            .where(eq(schema.memories.projectId, project.id));
         stats.totalMemories = countResult.length;
         // Count by type
         if (config.isTeamMode) {
             // PostgreSQL - use raw query for GROUP BY
-            const typeCounts = await db.execute(sql `
-        SELECT type, COUNT(*) as count
-        FROM memories
-        ${project ? sql `WHERE project_id = ${project.id}` : sql ``}
-        GROUP BY type
+            const typeCounts = await db.execute(sql `
+        SELECT type, COUNT(*) as count
+        FROM memories
+        ${sql `WHERE project_id = ${project.id}`}
+        GROUP BY type
       `);
             for (const row of typeCounts.rows) {
                 stats.byType[row.type] = Number(row.count);
@@ -51,7 +60,7 @@ export async function getMemoryStats(projectPath = process.cwd()) {
             const allMemories = await db
                 .select({ type: schema.memories.type })
                 .from(schema.memories)
-                .where(project ? eq(schema.memories.projectId, project.id) : undefined);
+                .where(eq(schema.memories.projectId, project.id));
             for (const mem of allMemories) {
                 const type = mem.type || 'unknown';
                 stats.byType[type] = (stats.byType[type] || 0) + 1;
@@ -61,13 +70,13 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         const oldest = await db
             .select({ createdAt: schema.memories.createdAt })
             .from(schema.memories)
-            .where(project ? eq(schema.memories.projectId, project.id) : undefined)
+            .where(eq(schema.memories.projectId, project.id))
             .orderBy(asc(schema.memories.createdAt))
             .limit(1);
         const newest = await db
             .select({ createdAt: schema.memories.createdAt })
             .from(schema.memories)
-            .where(project ? eq(schema.memories.projectId, project.id) : undefined)
+            .where(eq(schema.memories.projectId, project.id))
             .orderBy(desc(schema.memories.createdAt))
             .limit(1);
         if (oldest.length > 0 && oldest[0].createdAt) {
@@ -76,11 +85,58 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         if (newest.length > 0 && newest[0].createdAt) {
             stats.newestMemory = newest[0].createdAt;
         }
+        // Learnings
+        const allLearnings = await db
+            .select({ category: schema.learnings.category, type: schema.learnings.type })
+            .from(schema.learnings)
+            .where(eq(schema.learnings.projectId, project.id));
+        stats.totalNotes = allLearnings.length;
+        for (const obs of allLearnings) {
+            const cat = obs.category || 'uncategorized';
+            stats.notesByCategory[cat] = (stats.notesByCategory[cat] || 0) + 1;
+        }
+        // Learnings by type
+        const learningTypes = ['success', 'failure', 'fix', 'insight'];
+        const learningRecords = allLearnings.filter((o) => {
+            const type = o.type || '';
+            return learningTypes.includes(type.toLowerCase());
+        });
+        stats.totalLearnings = learningRecords.length;
+        // Count by type
+        for (const obs of learningRecords) {
+            const type = obs.type || 'unknown';
+            stats.learningsByType[type] = (stats.learningsByType[type] || 0) + 1;
+        }
+        // Links
+        // Links are scoped via their associated memories
+        if (config.isTeamMode) {
+            // PostgreSQL - use raw query to join through memories
+            const linksCount = await db.execute(sql `
+        SELECT COUNT(*) as count FROM memory_associations ma
+        JOIN memories m1 ON ma.from_memory_id = m1.id
+        JOIN memories m2 ON ma.to_memory_id = m2.id
+        ${project ? sql `WHERE m1.project_id = ${project.id} OR m2.project_id = ${project.id}` : sql ``}
+      `);
+            stats.totalLinks = Number(linksCount.rows[0]?.count || 0);
+        }
+        else {
+            // SQLite - get all and filter in memory
+            const allLinks = await db
+                .select({
+                fromProjectId: schema.memories.projectId,
+                toProjectId: schema.memories.projectId
+            })
+                .from(schema.memoryAssociations)
+                .innerJoin(schema.memories, eq(schema.memoryAssociations.fromMemoryId, schema.memories.id))
+                .where(project ? eq(schema.memories.projectId, project.id) : undefined);
+            stats.totalLinks = allLinks.length;
+        }
     }
     catch (error) {
         // Return empty stats on error
         console.error('Error getting memory stats:', error);
     }
+    stats.signal = await getProjectSignalStats(projectPath);
     return stats;
 }
 import { eq, sql, asc, desc } from 'drizzle-orm';

package/dist/core/memory/temporal-facts.js

@@ -16,6 +16,10 @@ import { parseTemporalFacts } from './temporal-parser.js';
 export async function checkTemporalValidity(memoryId) {
     try {
         const db = await getDb();
+        if (!db) {
+            // Graceful fallback when database is unavailable
+            return { isValid: true, confidence: 0.5 };
+        }
         const schema = await getSchema();
         const memories = await db
             .select()
@@ -75,6 +79,10 @@ export async function supersedeOldTemporalFacts(newMemoryId, content, projectId)
     };
     try {
         const db = await getDb();
+        if (!db) {
+            // Graceful fallback when database is unavailable
+            return result;
+        }
         const schema = await getSchema();
         // Parse temporal facts from new content
         const temporalFacts = await parseTemporalFacts(content);
@@ -180,6 +188,10 @@ export async function cleanupExpiredTemporalFacts(projectId) {
     let expiredCount = 0;
     try {
         const db = await getDb();
+        if (!db) {
+            // Graceful fallback when database is unavailable
+            return 0;
+        }
         const schema = await getSchema();
         const now = new Date();
         const whereClause = projectId
@@ -217,6 +229,15 @@ export async function cleanupExpiredTemporalFacts(projectId) {
 export async function getTemporalFactsStats(projectId) {
     try {
         const db = await getDb();
+        if (!db) {
+            // Graceful fallback when database is unavailable
+            return {
+                totalTemporalFacts: 0,
+                validFacts: 0,
+                expiredFacts: 0,
+                supersededFacts: 0,
+            };
+        }
         const schema = await getSchema();
         const now = new Date();
         const whereClause = projectId

package/dist/core/memory/trigger-detector.d.ts

@@ -6,9 +6,16 @@ export interface MemorySignals {
         preference: boolean;
         workflowRule: boolean;
         lesson: boolean;
+        note: boolean;
+        important: boolean;
+        hack: boolean;
+        why: boolean;
+        todo: boolean;
+        fixme: boolean;
     };
-    suggestedType: 'observation' | 'fact' | 'decision' | 'context' | 'preference';
+    suggestedType: 'observation' | 'fact' | 'decision' | 'context' | 'preference' | 'task';
     priority: 'normal' | 'high';
+    confidence: 'certain' | 'speculative' | 'inferred';
 }
 export declare function detectMemorySignals(content: string): MemorySignals;
 //# sourceMappingURL=trigger-detector.d.ts.map