squish-memory 1.1.5 → 1.2.1

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

@@ -1,155 +0,0 @@
-/** Feedback Tracker - Track memory usage in responses for Echo/Fizzle loop */
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-import { getDb } from '../../db/index.js';
-import { memoryFeedback, memories } from '../../db/drizzle/schema-sqlite.js';
-import { eq, and } from 'drizzle-orm';
-import { analyzeResponseForMemoryReferences, mightContainMemoryReferences } from './response-analyzer.js';
-const injectionTracker = new Map();
-export async function recordInjection(sessionId, memoryIds, memoryContent) {
-    if (!config.feedbackTrackingEnabled)
-        return;
-    injectionTracker.set(sessionId, {
-        memoryIds,
-        memoryContent,
-        injectedAt: new Date(),
-    });
-    const db = await getDb();
-    if (!db)
-        return;
-    try {
-        const now = new Date();
-        const sqliteDb = db;
-        for (const memoryId of memoryIds) {
-            await sqliteDb.insert(memoryFeedback).values({
-                memoryId,
-                sessionId,
-                wasInjected: true,
-                wasReferenced: false,
-                referenceCount: 0,
-                retrievalPriorityDelta: 0,
-                injectedAt: now,
-            }).onConflictDoNothing();
-        }
-        logger.debug(`[FeedbackTracker] Recorded injection of ${memoryIds.length} memories for session ${sessionId}`);
-    }
-    catch (error) {
-        logger.error('[FeedbackTracker] Failed to record injection:', error);
-    }
-}
-export async function analyzeAndRecordFeedback(sessionId, responseText) {
-    if (!config.feedbackTrackingEnabled)
-        return;
-    const injection = injectionTracker.get(sessionId);
-    if (!injection) {
-        logger.debug(`[FeedbackTracker] No injection record for session ${sessionId}`);
-        return;
-    }
-    if (!mightContainMemoryReferences(responseText)) {
-        await applyFizzlePenalty(injection.memoryIds);
-        injectionTracker.delete(sessionId);
-        return;
-    }
-    const analysis = analyzeResponseForMemoryReferences(responseText, injection.memoryIds, injection.memoryContent);
-    const db = await getDb();
-    if (!db)
-        return;
-    try {
-        const now = new Date();
-        const sqliteDb = db;
-        for (const memoryId of injection.memoryIds) {
-            const wasReferenced = analysis.referencedMemoryIds.includes(memoryId);
-            const delta = wasReferenced ? config.feedbackEchoBonus : -config.feedbackFizzlePenalty;
-            const existing = await sqliteDb
-                .select()
-                .from(memoryFeedback)
-                .where(and(eq(memoryFeedback.memoryId, memoryId), eq(memoryFeedback.sessionId, sessionId)))
-                .limit(1);
-            if (existing.length > 0) {
-                await sqliteDb
-                    .update(memoryFeedback)
-                    .set({
-                    wasReferenced,
-                    referenceCount: wasReferenced ? 1 : 0,
-                    retrievalPriorityDelta: delta,
-                    referencedAt: wasReferenced ? now : null,
-                })
-                    .where(eq(memoryFeedback.id, existing[0].id));
-            }
-            await updateRetrievalPriority(memoryId, delta);
-        }
-        logger.info(`[FeedbackTracker] Feedback recorded: ${analysis.referenceCount} echoes, ${injection.memoryIds.length - analysis.referenceCount} fizzles`);
-        injectionTracker.delete(sessionId);
-    }
-    catch (error) {
-        logger.error('[FeedbackTracker] Failed to record feedback:', error);
-    }
-}
-async function applyFizzlePenalty(memoryIds) {
-    try {
-        for (const memoryId of memoryIds) {
-            await updateRetrievalPriority(memoryId, -config.feedbackFizzlePenalty);
-        }
-        logger.debug(`[FeedbackTracker] Applied fizzle penalty to ${memoryIds.length} memories`);
-    }
-    catch (error) {
-        logger.error('[FeedbackTracker] Failed to apply fizzle penalty:', error);
-    }
-}
-export async function updateRetrievalPriority(memoryId, delta) {
-    const db = await getDb();
-    if (!db)
-        return;
-    try {
-        const sqliteDb = db;
-        const [memory] = await sqliteDb
-            .select({ retrievalPriority: memories.retrievalPriority })
-            .from(memories)
-            .where(eq(memories.id, memoryId))
-            .limit(1);
-        if (!memory)
-            return;
-        const currentPriority = memory.retrievalPriority ?? 50;
-        const newPriority = Math.max(0, Math.min(100, currentPriority + delta));
-        await sqliteDb
-            .update(memories)
-            .set({ retrievalPriority: newPriority })
-            .where(eq(memories.id, memoryId));
-        logger.debug(`[FeedbackTracker] Updated priority for ${memoryId}: ${currentPriority} -> ${newPriority}`);
-    }
-    catch (error) {
-        logger.error('[FeedbackTracker] Failed to update retrieval priority:', error);
-    }
-}
-export async function getMemoryFeedbackStats(memoryId) {
-    const db = await getDb();
-    if (!db) {
-        return { totalInjections: 0, totalReferences: 0, echoRate: 0, averagePriorityDelta: 0 };
-    }
-    try {
-        const sqliteDb = db;
-        const records = await sqliteDb
-            .select()
-            .from(memoryFeedback)
-            .where(eq(memoryFeedback.memoryId, memoryId));
-        const totalInjections = records.filter((r) => r.wasInjected).length;
-        const totalReferences = records.filter((r) => r.wasReferenced).length;
-        const echoRate = totalInjections > 0 ? totalReferences / totalInjections : 0;
-        const totalDelta = records.reduce((sum, r) => sum + (r.retrievalPriorityDelta ?? 0), 0);
-        const averagePriorityDelta = records.length > 0 ? totalDelta / records.length : 0;
-        return { totalInjections, totalReferences, echoRate, averagePriorityDelta };
-    }
-    catch (error) {
-        logger.error('[FeedbackTracker] Failed to get feedback stats:', error);
-        return { totalInjections: 0, totalReferences: 0, echoRate: 0, averagePriorityDelta: 0 };
-    }
-}
-export function cleanupInjectionTracker(maxAgeMs = 3600000) {
-    const now = Date.now();
-    for (const [sessionId, injection] of injectionTracker.entries()) {
-        if (now - injection.injectedAt.getTime() > maxAgeMs) {
-            injectionTracker.delete(sessionId);
-        }
-    }
-}
-//# sourceMappingURL=feedback-tracker.js.map

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

@@ -1,88 +0,0 @@
-/**
- * Memory Lifecycle Hooks
- *
- * Provides event hooks for memory operations:
-  * - memoryCreated: When a memory is stored (DB or markdown files)
- * - memoryUpdated: When a memory is updated
- * - memoryDeleted: When a memory is deleted
- * - tierChange: When memory tier changes (hot/warm/cold)
- * - decayApplied: When decay score is updated
- *
- * Each hook can have sync and async handlers.
- * Usage: Register handlers to auto-capture, sync to external systems, etc.
- */
-export type HookEvent = 'memoryCreated' | 'memoryUpdated' | 'memoryDeleted' | 'tierChange' | 'decayApplied';
-export interface MemoryHookContext {
-    memoryId: string;
-    content: string;
-    type: string;
-    tags: string[];
-    project?: string;
-    source?: string;
-    tier?: string;
-    importance?: number;
-    oldContent?: string;
-}
-export interface TierChangeContext extends MemoryHookContext {
-    oldTier: string;
-    newTier: string;
-}
-export interface DecayContext extends MemoryHookContext {
-    oldScore: number;
-    newScore: number;
-}
-export type HookHandler<T = MemoryHookContext> = (context: T) => void | Promise<void>;
-/**
- * Register a hook handler for a specific event
- */
-export declare function registerHook(event: HookEvent, handler: HookHandler, priority?: number): void;
-/**
- * Unregister a hook handler
- */
-export declare function unregisterHook(event: HookEvent, handler: HookHandler): void;
-/**
- * Clear all hooks for an event
- */
-export declare function clearHooks(event?: HookEvent): void;
-/**
- * Get registered hooks for an event
- */
-export declare function getHooks(event: HookEvent): HookHandler[];
-/**
- * List all registered hooks (for debugging)
- */
-export declare function listHooks(): {
-    event: HookEvent;
-    priority: number;
-}[];
-/**
- * Trigger memoryCreated hooks
- * Called when a memory is stored in DB or markdown files
- */
-export declare function triggerMemoryCreated(context: MemoryHookContext): Promise<void>;
-/**
- * Trigger memoryUpdated hooks
- * Called when a memory content/tags/etc changes
- */
-export declare function triggerMemoryUpdated(context: MemoryHookContext, oldContent?: string): Promise<void>;
-/**
- * Trigger memoryDeleted hooks
- * Called when a memory is deleted
- */
-export declare function triggerMemoryDeleted(context: MemoryHookContext): Promise<void>;
-/**
- * Trigger tierChange hooks
- * Called when memory tier changes
- */
-export declare function triggerTierChange(context: TierChangeContext): Promise<void>;
-/**
- * Trigger decayApplied hooks
- * Called when memory decay score changes
- */
-export declare function triggerDecayApplied(context: DecayContext): Promise<void>;
-/**
- * Built-in hook: Auto-save to memory files when storing to DB
- * Use this to have dual storage (DB + markdown files)
- */
-export declare function createMarkdownAutoSyncHook(): (context: MemoryHookContext) => Promise<void>;
-//# sourceMappingURL=hooks.d.ts.map

package/dist/core/memory/hooks.js

@@ -1,174 +0,0 @@
-/**
- * Memory Lifecycle Hooks
- *
- * Provides event hooks for memory operations:
-  * - memoryCreated: When a memory is stored (DB or markdown files)
- * - memoryUpdated: When a memory is updated
- * - memoryDeleted: When a memory is deleted
- * - tierChange: When memory tier changes (hot/warm/cold)
- * - decayApplied: When decay score is updated
- *
- * Each hook can have sync and async handlers.
- * Usage: Register handlers to auto-capture, sync to external systems, etc.
- */
-import { logger } from '../logger.js';
-// Global hook registry
-const hooks = [];
-/**
- * Register a hook handler for a specific event
- */
-export function registerHook(event, handler, priority = 100) {
-    hooks.push({ event, handler, priority });
-    hooks.sort((a, b) => b.priority - a.priority);
-    logger.info('[Hooks] Registered handler for: ' + event + ' (priority: ' + priority + ')');
-}
-/**
- * Unregister a hook handler
- */
-export function unregisterHook(event, handler) {
-    const idx = hooks.findIndex(h => h.event === event && h.handler === handler);
-    if (idx !== -1) {
-        hooks.splice(idx, 1);
-        logger.info('[Hooks] Unregistered handler for: ' + event);
-    }
-}
-/**
- * Clear all hooks for an event
- */
-export function clearHooks(event) {
-    if (event) {
-        const before = hooks.length;
-        const filtered = hooks.filter(h => h.event !== event);
-        hooks.length = 0;
-        hooks.push(...filtered);
-        logger.info('[Hooks] Cleared ' + (before - filtered.length) + ' hooks for: ' + event);
-    }
-    else {
-        const count = hooks.length;
-        hooks.length = 0;
-        logger.info('[Hooks] Cleared all ' + count + ' hooks');
-    }
-}
-/**
- * Get registered hooks for an event
- */
-export function getHooks(event) {
-    return hooks.filter(h => h.event === event).map(h => h.handler);
-}
-/**
- * List all registered hooks (for debugging)
- */
-export function listHooks() {
-    return hooks.map(h => ({ event: h.event, priority: h.priority }));
-}
-// --- Trigger functions ---
-/**
- * Trigger memoryCreated hooks
- * Called when a memory is stored in DB or markdown files
- */
-export async function triggerMemoryCreated(context) {
-    const handlers = getHooks('memoryCreated');
-    for (const handler of handlers) {
-        try {
-            const result = handler(context);
-            if (result instanceof Promise) {
-                await result;
-            }
-        }
-        catch (error) {
-            logger.error('[Hooks] Error in memoryCreated handler: ' + error);
-        }
-    }
-}
-/**
- * Trigger memoryUpdated hooks
- * Called when a memory content/tags/etc changes
- */
-export async function triggerMemoryUpdated(context, oldContent) {
-    const handlers = getHooks('memoryUpdated');
-    for (const handler of handlers) {
-        try {
-            const result = handler({ ...context, oldContent: oldContent || '' });
-            if (result instanceof Promise) {
-                await result;
-            }
-        }
-        catch (error) {
-            logger.error('[Hooks] Error in memoryUpdated handler: ' + error);
-        }
-    }
-}
-/**
- * Trigger memoryDeleted hooks
- * Called when a memory is deleted
- */
-export async function triggerMemoryDeleted(context) {
-    const handlers = getHooks('memoryDeleted');
-    for (const handler of handlers) {
-        try {
-            const result = handler(context);
-            if (result instanceof Promise) {
-                await result;
-            }
-        }
-        catch (error) {
-            logger.error('[Hooks] Error in memoryDeleted handler: ' + error);
-        }
-    }
-}
-/**
- * Trigger tierChange hooks
- * Called when memory tier changes
- */
-export async function triggerTierChange(context) {
-    const handlers = getHooks('tierChange');
-    for (const handler of handlers) {
-        try {
-            const result = handler(context);
-            if (result instanceof Promise) {
-                await result;
-            }
-        }
-        catch (error) {
-            logger.error('[Hooks] Error in tierChange handler: ' + error);
-        }
-    }
-}
-/**
- * Trigger decayApplied hooks
- * Called when memory decay score changes
- */
-export async function triggerDecayApplied(context) {
-    const handlers = getHooks('decayApplied');
-    for (const handler of handlers) {
-        try {
-            const result = handler(context);
-            if (result instanceof Promise) {
-                await result;
-            }
-        }
-        catch (error) {
-            logger.error('[Hooks] Error in decayApplied handler: ' + error);
-        }
-    }
-}
-/**
- * Built-in hook: Auto-save to memory files when storing to DB
- * Use this to have dual storage (DB + markdown files)
- */
-export function createMarkdownAutoSyncHook() {
-    return async function markdownAutoSync(context) {
-        if (context.tier === 'hot') {
-            const { saveToMarkdown } = await import('./markdown/markdown-storage.js');
-            await saveToMarkdown({
-                content: context.content,
-                type: context.type,
-                tags: context.tags,
-                project: context.project,
-                source: context.source,
-            });
-            logger.info('[Hooks] Auto-synced memory to markdown: ' + context.memoryId);
-        }
-    };
-}
-//# sourceMappingURL=hooks.js.map

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

@@ -1,29 +0,0 @@
-import { hybridScore, HybridScorerOptions } from './hybrid-scorer.js';
-import { SearchInput, MemoryRecord } from './memories.js';
-export interface HybridSearchOptions extends SearchInput {
-    candidateLimit?: number;
-    resultLimit?: number;
-    hybridOptions?: HybridScorerOptions;
-    queryEntities?: string[];
-    sessionId?: string;
-    skipRewrite?: boolean;
-}
-export interface HybridSearchResult extends MemoryRecord {
-    hybridScore: number;
-    semanticScore: number;
-    recencyScore: number;
-    coactivationScore: number;
-    importanceScore: number;
-    confidenceScore: number;
-    feedbackScore: number;
-    entityBoost: number;
-    rank: number;
-    queryRewrite?: {
-        original: string;
-        rewritten: string;
-        method: string;
-    };
-}
-export declare function applyEntityBoostAndRerank(scored: Awaited<ReturnType<typeof hybridScore>>): Awaited<ReturnType<typeof hybridScore>>;
-export declare function hybridSearch(options: HybridSearchOptions): Promise<HybridSearchResult[]>;
-//# sourceMappingURL=hybrid-retrieval.d.ts.map

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

@@ -1,139 +0,0 @@
-import { hybridScore } from './hybrid-scorer.js';
-import { getEmbedding } from '../embeddings.js';
-import { search } from './memories.js';
-import { filterByEntities } from './entity-resolver.js';
-import { rewriteQuery, wouldBenefitFromRewrite } from './query-rewriter.js';
-import { collectRecentContext } from './context-collector.js';
-import { config } from '../../config.js';
-import { logger } from '../logger.js';
-import { startTrace, addQueryRewriteStage, addCandidateRetrievalStage, addEntityFilteringStage, addHybridScoringStage, addRerankingStage, completeTrace, } from '../tracing/collector.js';
-export function applyEntityBoostAndRerank(scored) {
-    const boosted = scored.map((item) => {
-        const rawBoost = item.memory._entityBoost;
-        const entityBoost = typeof rawBoost === 'number' ? rawBoost : 0.5;
-        const multiplier = 0.8 + entityBoost * 0.4;
-        return {
-            ...item,
-            totalScore: Math.min(100, Math.round(item.totalScore * multiplier * 100) / 100),
-        };
-    });
-    boosted.sort((a, b) => b.totalScore - a.totalScore);
-    for (let i = 0; i < boosted.length; i++) {
-        boosted[i].rank = i + 1;
-    }
-    return boosted;
-}
-export async function hybridSearch(options) {
-    const candidateLimit = options.candidateLimit ?? 50;
-    const resultLimit = options.resultLimit ?? options.limit ?? 5;
-    // Start trace if sessionId provided
-    const sessionId = options.sessionId || 'unknown';
-    const traceId = await startTrace(sessionId, options.query);
-    let query = options.query;
-    let rewriteInfo = null;
-    // Query rewriting stage
-    if (config.queryRewritingEnabled && !options.skipRewrite && options.sessionId) {
-        const rewriteStart = Date.now();
-        try {
-            const context = await collectRecentContext(options.sessionId, config.queryRewritingContextMessages);
-            if (wouldBenefitFromRewrite(query) || context.length > 0) {
-                const result = await rewriteQuery(query, context);
-                if (result.rewritten !== result.original) {
-                    rewriteInfo = {
-                        original: result.original,
-                        rewritten: result.rewritten,
-                        method: result.method,
-                    };
-                    query = result.rewritten;
-                    logger.info(`[HybridSearch] Query rewritten: "${result.original}" -> "${result.rewritten}" (${result.method})`);
-                }
-                // Record query rewrite stage
-                await addQueryRewriteStage(traceId, {
-                    original: result.original,
-                    rewritten: result.rewritten,
-                    method: result.method,
-                    timeMs: Date.now() - rewriteStart,
-                });
-            }
-        }
-        catch (error) {
-            logger.warn(`[HybridSearch] Query rewriting failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    // Get embedding
-    const queryEmbedding = await getEmbedding(query);
-    // Candidate retrieval stage
-    const retrievalStart = Date.now();
-    const candidates = await search({
-        ...options,
-        limit: candidateLimit,
-    });
-    await addCandidateRetrievalStage(traceId, {
-        candidates: candidates.length,
-        timeMs: Date.now() - retrievalStart,
-    });
-    if (candidates.length === 0) {
-        await completeTrace(traceId, []);
-        return [];
-    }
-    // Entity filtering stage
-    const filteringStart = Date.now();
-    const entityScored = filterByEntities(candidates, options.queryEntities || []);
-    await addEntityFilteringStage(traceId, {
-        entities: options.queryEntities || [],
-        results: entityScored.length,
-        timeMs: Date.now() - filteringStart,
-    });
-    const boostedCandidates = entityScored.map(({ memory, entityBoost }) => ({
-        ...memory,
-        _entityBoost: entityBoost,
-    }));
-    // Hybrid scoring stage
-    const scoringStart = Date.now();
-    const scored = await hybridScore(queryEmbedding, boostedCandidates, {
-        ...options.hybridOptions,
-        weights: {
-            semantic: 0.30,
-            recency: 0.20,
-            coactivation: 0.10,
-            importance: 0.15,
-            confidence: 0.15,
-            feedback: 0.10,
-            ...options.hybridOptions?.weights,
-        },
-        decayDays: 7,
-    });
-    await addHybridScoringStage(traceId, {
-        results: scored.length,
-        timeMs: Date.now() - scoringStart,
-    });
-    // Reranking stage
-    const rerankStart = Date.now();
-    const reranked = applyEntityBoostAndRerank(scored);
-    await addRerankingStage(traceId, {
-        results: reranked.length,
-        timeMs: Date.now() - rerankStart,
-    });
-    const topResults = reranked.slice(0, resultLimit);
-    // Complete trace with results
-    const traceResults = topResults.map((r) => ({
-        type: r.memory?.type,
-        content: r.memory?.content,
-        hybridScore: r.totalScore,
-    }));
-    await completeTrace(traceId, traceResults);
-    return topResults.map((scoredItem, index) => ({
-        ...scoredItem.memory,
-        hybridScore: scoredItem.totalScore,
-        semanticScore: scoredItem.components.semantic,
-        recencyScore: scoredItem.components.recency,
-        coactivationScore: scoredItem.components.coactivation,
-        importanceScore: scoredItem.components.importance,
-        confidenceScore: scoredItem.components.confidence,
-        feedbackScore: scoredItem.components.feedback,
-        entityBoost: scoredItem.memory._entityBoost || 0.5,
-        rank: index + 1,
-        ...(rewriteInfo && { queryRewrite: rewriteInfo }),
-    }));
-}
-//# sourceMappingURL=hybrid-retrieval.js.map

package/dist/core/memory/hybrid-scorer.d.ts

@@ -1,40 +0,0 @@
-/** Hybrid Scorer - Multi-factor relevance scoring for memory ranking */
-export interface ScoredMemory {
-    memoryId: string;
-    memory: any;
-    totalScore: number;
-    components: {
-        semantic: number;
-        recency: number;
-        coactivation: number;
-        importance: number;
-        confidence: number;
-        feedback: number;
-    };
-    rank: number;
-    explanation: string;
-}
-export interface HybridScorerOptions {
-    weights?: {
-        semantic?: number;
-        recency?: number;
-        coactivation?: number;
-        importance?: number;
-        confidence?: number;
-        feedback?: number;
-    };
-    decayDays?: number;
-    minSemanticScore?: number;
-    includeExplanation?: boolean;
-}
-export declare function hybridScore(queryEmbedding: number[] | null, memories: any[], options?: HybridScorerOptions): Promise<ScoredMemory[]>;
-export declare function scoreAndRankMemories(queryEmbedding: number[] | null, memories: any[], topK?: number, options?: HybridScorerOptions): Promise<ScoredMemory[]>;
-export declare function getScoreDistribution(scored: ScoredMemory[]): {
-    min: number;
-    max: number;
-    avg: number;
-    median: number;
-    p95: number;
-    p99: number;
-};
-//# sourceMappingURL=hybrid-scorer.d.ts.map