squish-memory 1.1.5 → 1.2.0

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/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

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/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

@@ -14,6 +14,16 @@ export interface MemoryStats {
     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 { requireProject } from '../../core/projects.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,7 +20,10 @@ 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 requireProject(projectPath);
+    const project = await ensureProject(projectPath);
+    if (!project) {
+        throw new Error(`Project not found: ${projectPath}`);
+    }
     const stats = {
         totalMemories: 0,
         byType: {},
@@ -29,7 +33,7 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         learningsByType: {},
         totalLinks: 0,
         projectPath,
-        mode: config.isTeamMode ? 'team' : 'local'
+        mode: config.isTeamMode ? 'team' : 'local',
     };
     try {
         // Count total memories
@@ -132,6 +136,7 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         // 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/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

package/dist/core/memory/trigger-detector.js

@@ -8,6 +8,15 @@ const EXPLICIT_TRIGGER_PATTERNS = [
     { label: 'save-this', regex: /\bsave\s+this\b/i },
     { label: 'log-this', regex: /\blog\s+this\b/i },
     { label: 'important', regex: /\bimportant\s*:/i },
+    // New: Rationale comment triggers
+    { label: 'NOTE', regex: /NOTE:/i },
+    { label: 'IMPORTANT', regex: /IMPORTANT:/i },
+    { label: 'HACK', regex: /HACK:/i },
+    { label: 'WHY', regex: /WHY:/i },
+    { label: 'TODO', regex: /TODO:/i },
+    { label: 'FIXME', regex: /FIXME:/i },
+    { label: 'XXX', regex: /XXX:/i },
+    { label: 'DEPRECATED', regex: /DEPRECATED:/i },
 ];
 export function detectMemorySignals(content) {
     const text = content.trim();
@@ -20,23 +29,51 @@ export function detectMemorySignals(content) {
             /\b(?:always|never)\b/i.test(text),
         workflowRule: /\b(?:let'?s\s+always\s+do\s+it\s+this\s+way|standard\s+workflow|runbook)\b/i.test(text),
         lesson: /\b(?:failed\s+because|lesson\s+learned|next\s+time|do\s+not\s+repeat|root\s+cause)\b/i.test(text),
+        // New: Rationale patterns from code comments
+        note: /NOTE:/i.test(text),
+        important: /IMPORTANT:/i.test(text),
+        hack: /HACK:/i.test(text),
+        why: /WHY:/i.test(text),
+        todo: /TODO:/i.test(text),
+        fixme: /FIXME:/i.test(text),
     };
     let suggestedType = 'observation';
-    if (implicit.preference)
-        suggestedType = 'preference';
+    // Priority order: decision > preference > lesson > workflowRule > rationale > fact
     if (implicit.decision)
         suggestedType = 'decision';
-    if (implicit.workflowRule || implicit.lesson)
+    else if (implicit.preference)
+        suggestedType = 'preference';
+    else if (implicit.workflowRule || implicit.lesson)
         suggestedType = 'context';
-    if (!implicit.decision && !implicit.preference && /\b(?:is|are|was|were|uses|has|have)\b/i.test(text)) {
+    else if (implicit.todo)
+        suggestedType = 'task';
+    else if (!implicit.decision && !implicit.preference && /\b(?:is|are|was|were|uses|has|have)\b/i.test(text)) {
         suggestedType = 'fact';
     }
-    const priority = explicitTriggers.length > 0 || implicit.correction ? 'high' : 'normal';
+    // Override for specific rationale markers
+    if (implicit.note || implicit.important)
+        suggestedType = 'observation';
+    if (implicit.why)
+        suggestedType = 'context';
+    // Determine confidence based on signal strength
+    let confidence = 'certain';
+    if (implicit.note || implicit.todo)
+        confidence = 'speculative';
+    if (implicit.hack || implicit.fixme)
+        confidence = 'certain'; // Known issues are certain
+    const priority = explicitTriggers.length > 0 ||
+        implicit.correction ||
+        implicit.important ||
+        implicit.hack ||
+        implicit.fixme
+        ? 'high'
+        : 'normal';
     return {
         explicitTriggers,
         implicit,
         suggestedType,
         priority,
+        confidence,
     };
 }
 //# sourceMappingURL=trigger-detector.js.map

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

@@ -1,5 +1,5 @@
 /**
- * Places Module - Spatial memory organization (Method of Loci)
+ * Places Module - Spatial memory organization
  *
  * Exports:
  * - places.ts: CRUD operations for places

package/dist/core/places/index.js

@@ -1,5 +1,5 @@
 /**
- * Places Module - Spatial memory organization (Method of Loci)
+ * Places Module - Spatial memory organization
  *
  * Exports:
  * - places.ts: CRUD operations for places