squish-memory 1.1.5 → 1.2.0

package/dist/core/memory/fact-deriver.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Fact Deriver
+ *
+ * Derives implicit facts from existing relationships in the knowledge graph.
+ * Example: works_on(A, X) + uses(X, Y) -> depends_on(A, Y)
+ */
+import type { RelationType } from '../graph/llm-entity-extractor.js';
+export interface DerivedFact {
+    fromEntityId: string;
+    fromEntityName: string;
+    toEntityId: string;
+    toEntityName: string;
+    relationType: RelationType;
+    rule: string;
+    confidence: number;
+    isDerived: boolean;
+}
+/**
+ * Derive implicit facts from existing relationships in the knowledge graph.
+ * Applies transitivity and causal rules to find new relationships.
+ */
+export declare function deriveFacts(projectId: string, options?: {
+    maxDerivations?: number;
+    minConfidence?: number;
+    storeResults?: boolean;
+}): Promise<DerivedFact[]>;
+/**
+ * Get all derived facts for a project.
+ */
+export declare function getDerivedFacts(projectId: string): Promise<DerivedFact[]>;
+//# sourceMappingURL=fact-deriver.d.ts.map

package/dist/core/memory/fact-deriver.js

@@ -0,0 +1,236 @@
+/**
+ * Fact Deriver
+ *
+ * Derives implicit facts from existing relationships in the knowledge graph.
+ * Example: works_on(A, X) + uses(X, Y) -> depends_on(A, Y)
+ */
+import { eq, and, or } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+const DERIVATION_RULES = [
+    // Transitivity rules
+    {
+        name: 'works_on_uses_depends_on',
+        fromType: 'works_on',
+        toType: 'uses',
+        derivedType: 'depends_on',
+        description: 'If A works on X and X uses Y, then A depends on Y',
+        confidence: 0.8,
+    },
+    {
+        name: 'manages_works_oversees',
+        fromType: 'manages',
+        toType: 'works_on',
+        derivedType: 'oversees',
+        description: 'If A manages B and B works on X, then A oversees X',
+        confidence: 0.75,
+    },
+    {
+        name: 'caused_affects_may_affect',
+        fromType: 'caused',
+        toType: 'affects',
+        derivedType: 'may_affect',
+        description: 'If X caused Y and Y affects Z, then X may affect Z',
+        confidence: 0.7,
+    },
+    {
+        name: 'part_of_contains',
+        fromType: 'part_of',
+        toType: 'contains',
+        derivedType: 'related_to',
+        description: 'If A is part of X and X contains B, then A is related to B',
+        confidence: 0.6,
+    },
+    {
+        name: 'uses_depends_on',
+        fromType: 'uses',
+        toType: 'depends_on',
+        derivedType: 'depends_on',
+        description: 'If A uses X and X depends on Y, then A depends on Y',
+        confidence: 0.85,
+    },
+    {
+        name: 'created_resolved',
+        fromType: 'created',
+        toType: 'resolved',
+        derivedType: 'related_to',
+        description: 'If A created X and X was resolved by B, then A is related to B',
+        confidence: 0.5,
+    },
+    {
+        name: 'blocks_depends_on',
+        fromType: 'blocks',
+        toType: 'depends_on',
+        derivedType: 'blocks',
+        description: 'If X blocks A and A depends on Y, then X may block Y',
+        confidence: 0.65,
+    },
+];
+// ─── Main Derivation Function ─────────────────────────────────────────────────
+/**
+ * Derive implicit facts from existing relationships in the knowledge graph.
+ * Applies transitivity and causal rules to find new relationships.
+ */
+export async function deriveFacts(projectId, options) {
+    const { maxDerivations = 50, minConfidence = 0.6, storeResults = true } = options || {};
+    const db = await getDb();
+    const schema = await getSchema();
+    // Get all entities for this project
+    const entities = await db
+        .select()
+        .from(schema.entities)
+        .where(eq(schema.entities.projectId, projectId));
+    if (entities.length < 2)
+        return [];
+    const entityMap = new Map(entities.map((e) => [e.id, e]));
+    const derivedFacts = [];
+    // Get all relations for this project's entities
+    const entityIds = entities.map((e) => e.id);
+    const allRelations = [];
+    // Fetch in batches to avoid query size limits
+    const batchSize = 100;
+    for (let i = 0; i < entityIds.length; i += batchSize) {
+        const batch = entityIds.slice(i, i + batchSize);
+        const relations = await db
+            .select()
+            .from(schema.entityRelations)
+            .where(or(...batch.map((id) => eq(schema.entityRelations.fromEntityId, id))));
+        allRelations.push(...relations);
+    }
+    // Build adjacency list for fast lookup
+    const outgoing = new Map();
+    for (const rel of allRelations) {
+        if (!outgoing.has(rel.fromEntityId)) {
+            outgoing.set(rel.fromEntityId, new Map());
+        }
+        outgoing.get(rel.fromEntityId).set(rel.toEntityId, {
+            relationType: rel.type,
+            weight: rel.weight || 1,
+        });
+    }
+    // Apply derivation rules
+    for (const rule of DERIVATION_RULES) {
+        if (derivedFacts.length >= maxDerivations)
+            break;
+        if (rule.confidence < minConfidence)
+            continue;
+        // Find all pairs where fromType matches
+        for (const [fromId, targets] of outgoing) {
+            if (derivedFacts.length >= maxDerivations)
+                break;
+            for (const [midId, fromRel] of targets) {
+                if (fromRel.relationType !== rule.fromType)
+                    continue;
+                // Check if midId has outgoing toType relations
+                const midTargets = outgoing.get(midId);
+                if (!midTargets)
+                    continue;
+                for (const [toId, toRel] of midTargets) {
+                    if (toRel.relationType !== rule.toType)
+                        continue;
+                    // Found a derivation: fromId --fromType--> midId --toType--> toId
+                    // Derive: fromId --derivedType--> toId
+                    const fromEntity = entityMap.get(fromId);
+                    const toEntity = entityMap.get(toId);
+                    if (!fromEntity || !toEntity)
+                        continue;
+                    // Check if this derived relation already exists
+                    const existing = await db
+                        .select()
+                        .from(schema.entityRelations)
+                        .where(and(eq(schema.entityRelations.fromEntityId, fromId), eq(schema.entityRelations.toEntityId, toId), eq(schema.entityRelations.type, rule.derivedType)))
+                        .limit(1);
+                    if (existing.length > 0)
+                        continue; // Already exists
+                    const derivedFact = {
+                        fromEntityId: fromId,
+                        fromEntityName: fromEntity.name,
+                        toEntityId: toId,
+                        toEntityName: toEntity.name,
+                        relationType: rule.derivedType,
+                        rule: rule.name,
+                        confidence: rule.confidence,
+                        isDerived: true,
+                    };
+                    derivedFacts.push(derivedFact);
+                    // Store the derived fact if requested
+                    if (storeResults) {
+                        try {
+                            await db.insert(schema.entityRelations).values({
+                                fromEntityId: fromId,
+                                toEntityId: toId,
+                                type: rule.derivedType,
+                                weight: Math.round(rule.confidence * 10),
+                                properties: {
+                                    derived: true,
+                                    rule: rule.name,
+                                    confidence: rule.confidence,
+                                    description: rule.description,
+                                },
+                            });
+                        }
+                        catch (error) {
+                            logger.debug('Error storing derived fact', {
+                                rule: rule.name,
+                                from: fromEntity.name,
+                                to: toEntity.name,
+                                error: error,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    logger.info('Fact derivation completed', {
+        projectId,
+        derivedCount: derivedFacts.length,
+        rulesApplied: DERIVATION_RULES.length,
+    });
+    return derivedFacts;
+}
+/**
+ * Get all derived facts for a project.
+ */
+export async function getDerivedFacts(projectId) {
+    const db = await getDb();
+    const schema = await getSchema();
+    // Get all entities for this project
+    const entities = await db
+        .select()
+        .from(schema.entities)
+        .where(eq(schema.entities.projectId, projectId));
+    const entityIds = entities.map((e) => e.id);
+    if (entityIds.length === 0)
+        return [];
+    // Get all derived relations
+    const derivedRelations = [];
+    const batchSize = 100;
+    for (let i = 0; i < entityIds.length; i += batchSize) {
+        const batch = entityIds.slice(i, i + batchSize);
+        const relations = await db
+            .select()
+            .from(schema.entityRelations)
+            .where(or(...batch.map((id) => eq(schema.entityRelations.fromEntityId, id))));
+        for (const rel of relations) {
+            const props = rel.properties;
+            if (props && props.derived === true) {
+                const fromEntity = entities.find((e) => e.id === rel.fromEntityId);
+                const toEntity = entities.find((e) => e.id === rel.toEntityId);
+                derivedRelations.push({
+                    fromEntityId: rel.fromEntityId,
+                    fromEntityName: fromEntity?.name || 'Unknown',
+                    toEntityId: rel.toEntityId,
+                    toEntityName: toEntity?.name || 'Unknown',
+                    relationType: rel.type,
+                    rule: props.rule || 'unknown',
+                    confidence: props.confidence || 0.5,
+                    isDerived: true,
+                });
+            }
+        }
+    }
+    return derivedRelations;
+}
+//# sourceMappingURL=fact-deriver.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 { 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';
+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 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 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,6 +1,8 @@
 /**
- * Hybrid Search - Combines BM25 keyword search with vector semantic search
- * Uses Reciprocal Rank Fusion (RRF) for result merging
+ * Vector Search - Pure semantic search with optional graph boosting + multi-session support
+ *
+ * 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 {
@@ -8,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