squish-memory 1.0.2 → 1.2.0

package/dist/core/memory/hooks.js

@@ -0,0 +1,174 @@
+/**
+ * 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 +1,27 @@
-import { hybridScore, HybridScorerOptions } from './hybrid-scorer.js';
-import { SearchInput, MemoryRecord } from './memories.js';
+import type { MemoryRecord } from '../lib/types.js';
+import type { SearchInput } 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;
+    coactivationScore: number;
     rank: number;
-    queryRewrite?: {
-        original: string;
-        rewritten: string;
-        method: string;
-    };
+    explanation: string;
 }
-export declare function applyEntityBoostAndRerank(scored: Awaited<ReturnType<typeof hybridScore>>): Awaited<ReturnType<typeof hybridScore>>;
+type ScoredItem = {
+    memoryId: string;
+    memory: Record<string, unknown>;
+    totalScore: number;
+    components: Record<string, number>;
+    rank: number;
+    explanation: string;
+};
+export declare function applyEntityBoostAndRerank<T extends ScoredItem>(scored: T[]): T[];
 export declare function hybridSearch(options: HybridSearchOptions): Promise<HybridSearchResult[]>;
+export {};
 //# sourceMappingURL=hybrid-retrieval.d.ts.map

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

@@ -1,139 +1,37 @@
-import { hybridScore } from './hybrid-scorer.js';
-import { getEmbedding } from '../embeddings.js';
-import { searchMemories } 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';
+import { hybridSearch as currentHybridSearch } from './hybrid-search.js';
 export function applyEntityBoostAndRerank(scored) {
-    const boosted = scored.map((item) => {
+    return scored
+        .map((item) => {
         const rawBoost = item.memory._entityBoost;
-        const entityBoost = typeof rawBoost === 'number' ? rawBoost : 0.5;
-        const multiplier = 0.8 + entityBoost * 0.4;
+        const entityBoost = typeof rawBoost === 'number' ? rawBoost : 0;
         return {
             ...item,
-            totalScore: Math.min(100, Math.round(item.totalScore * multiplier * 100) / 100),
+            totalScore: item.totalScore + entityBoost * 20,
         };
-    });
-    boosted.sort((a, b) => b.totalScore - a.totalScore);
-    for (let i = 0; i < boosted.length; i++) {
-        boosted[i].rank = i + 1;
-    }
-    return boosted;
+    })
+        .sort((a, b) => b.totalScore - a.totalScore)
+        .map((item, index) => ({
+        ...item,
+        rank: index + 1,
+    }));
 }
 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 searchMemories({
-        ...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 limit = options.resultLimit ?? options.limit ?? 5;
+    const results = await currentHybridSearch(options, {
+        limit,
+        project: options.project,
+        type: options.type,
+        tags: options.tags,
     });
-    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,
+    return results.map((result, index) => ({
+        ...result,
+        hybridScore: result.similarity ?? 0,
+        semanticScore: result.similarity ?? 0,
+        recencyScore: 0,
+        importanceScore: typeof result.importance === 'number' ? result.importance : 0,
+        coactivationScore: 0,
         rank: index + 1,
-        ...(rewriteInfo && { queryRewrite: rewriteInfo }),
+        explanation: 'Compatibility result from current hybrid search',
     }));
 }
 //# sourceMappingURL=hybrid-retrieval.js.map

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

@@ -1,5 +1,6 @@
 /** Hybrid Scorer - Multi-factor relevance scoring for memory ranking */
 import { logger } from '../../core/logger.js';
+import { cosineSimilarity } from '../utils/vector-operations.js';
 export async function hybridScore(queryEmbedding, memories, options = {}) {
     const weights = {
         semantic: options.weights?.semantic ?? 0.30,
@@ -70,8 +71,8 @@ function calculateSemanticScore(queryEmbedding, memory) {
         }
         if (!memoryEmbedding || memoryEmbedding.length === 0)
             return 50;
-        const cosineSimilarity = calculateCosineSimilarity(queryEmbedding, memoryEmbedding);
-        return Math.max(0, Math.min(100, (cosineSimilarity + 1) * 50));
+        const semanticScore = cosineSimilarity(queryEmbedding, memoryEmbedding);
+        return Math.max(0, Math.min(100, (semanticScore + 1) * 50));
     }
     catch (error) {
         logger.error('Error calculating semantic score', error);
@@ -144,10 +145,10 @@ function calculateCoactivationScore(memory) {
 }
 function calculateImportanceScore(memory) {
     let score = 50;
+    // Simplified: hot or cold only (warm removed)
     if (memory.tier === 'hot')
         score += 30;
-    else if (memory.tier === 'warm')
-        score += 15;
+    // No bonus for cold - it's the fallback
     if (memory.relevanceScore)
         score += memory.relevanceScore * 0.2;
     if (memory.isPinned)
@@ -207,23 +208,6 @@ function calculateFeedbackScore(memory) {
     const retrievalPriority = memory.retrievalPriority ?? 50;
     return Math.max(0, Math.min(100, retrievalPriority));
 }
-function calculateCosineSimilarity(vecA, vecB) {
-    if (vecA.length !== vecB.length)
-        return 0;
-    let dotProduct = 0;
-    let magnitudeA = 0;
-    let magnitudeB = 0;
-    for (let i = 0; i < vecA.length; i++) {
-        dotProduct += vecA[i] * vecB[i];
-        magnitudeA += vecA[i] * vecA[i];
-        magnitudeB += vecB[i] * vecB[i];
-    }
-    magnitudeA = Math.sqrt(magnitudeA);
-    magnitudeB = Math.sqrt(magnitudeB);
-    if (magnitudeA === 0 || magnitudeB === 0)
-        return 0;
-    return dotProduct / (magnitudeA * magnitudeB);
-}
 function generateScoreExplanation(components, weights, memory) {
     const parts = [];
     if (components.semantic > 70)
@@ -238,10 +222,9 @@ function generateScoreExplanation(components, weights, memory) {
         parts.push('moderately recent');
     else
         parts.push('older');
+    // Simplified: hot or cold only (warm removed)
     if (memory.tier === 'hot')
         parts.push('active memory');
-    else if (memory.tier === 'warm')
-        parts.push('accessible memory');
     else
         parts.push('archived memory');
     if (components.coactivation > 60)

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

@@ -1,11 +1,8 @@
 /**
- * Hybrid Search - Combines BM25 keyword search with vector semantic search
- * Uses Reciprocal Rank Fusion (RRF) for intelligent result merging
+ * Vector Search - Pure semantic search with optional graph boosting + multi-session support
  *
- * Based on research showing 40-60% improvement over pure vector search:
- * - BM25 excels at exact keyword matches
- * - Vector search captures semantic similarity
- * - RRF merges both without score calibration issues
+ * Uses cosine similarity on embeddings + optional graph boost
+ * BM25 removed - use qmd-client for hot tier (BM25 + vectors + reranking)
  */
 import type { SearchResult, SearchInput } from './memories.js';
 export interface HybridSearchOptions {
@@ -13,13 +10,14 @@ export interface HybridSearchOptions {
     project?: string;
     type?: string;
     tags?: string[];
-    /** Weight for BM25 results (0-1), default 0.5 */
-    bm25Weight?: number;
-    /** Weight for vector results (0-1), default 0.5 */
-    vectorWeight?: number;
+    enableMultiSession?: boolean;
+    enableGraphTraversal?: boolean;
+    enableHeuristics?: boolean;
+    includeAssociations?: boolean;
 }
 /**
- * Main hybrid search function - combines BM25 and vector search with RRF
+ * Main search function - vectors + graph boost + heuristics + places + sessions
+ * Unified search integrating Places, Graph, and Memory
  */
 export declare function hybridSearch(input: SearchInput, options?: HybridSearchOptions): Promise<SearchResult[]>;
 //# sourceMappingURL=hybrid-search.d.ts.map