squish-memory 1.0.2 → 1.2.0

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

@@ -1,116 +1,472 @@
 /**
- * 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 { getDb } from '../../db/index.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { createDatabaseClient } from '../storage/database.js';
 import { getEmbedding } from '../../core/embeddings.js';
-import { getProjectByPath } from '../../core/projects.js';
-import { fromSqliteTags, normalizeTags } from './serialization.js';
+import { requireProject } from '../../core/projects.js';
+import { deserializeTags, deserializeMetadata, normalizeTags } from './serialization.js';
+import { computeGraphBoost } from '../search/graph-boost.js';
+import { normalizeTimestamp } from '../lib/utils.js';
+import { parseEmbedding } from '../lib/parse-embedding.js';
+import { cosineSimilarity } from '../utils/vector-operations.js';
+import config from '../../config.js';
+import { getRelatedMemories } from '../associations.js';
+import { getPlaceMemories } from '../places/memory-places.js';
+import { getPlaceByType } from '../places/places.js';
+import { multiHopSearch } from '../graph/multi-hop-retrieval.js';
+import { logger } from '../logger.js';
 /**
- * Reciprocal Rank Fusion (RRF) constant
- * Higher values = more influence from lower-ranked items
- * 60 is the standard value used in research
+ * Detect if query asks about time (temporal queries)
  */
-const RRF_K = 60;
+function isTemporalQuery(query) {
+    const temporalIndicators = [
+        'when', 'how long', 'how many', 'ago', 'since', 'until',
+        'before', 'after', 'earlier', 'later', 'yesterday', 'tomorrow',
+        'last week', 'next week', 'last month', 'next month'
+    ];
+    const lower = query.toLowerCase();
+    return temporalIndicators.some(w => lower.includes(w));
+}
+/**
+ * Detect if query spans multiple sessions (multi-hop queries)
+ */
+function isMultiSessionQuery(query) {
+    const multiSessionIndicators = [
+        'when', 'then', 'before', 'after', 'earlier', 'later',
+        'previous', 'next', 'first', 'later', 'subsequently',
+        'across', 'between', 'both', 'another', 'different'
+    ];
+    const lower = query.toLowerCase();
+    return multiSessionIndicators.some(w => lower.includes(w));
+}
 /**
- * Main hybrid search function - combines BM25 and vector search with RRF
+ * Check if content contains date/time references
+ */
+function hasDateReference(content) {
+    const datePatterns = [
+        /\b\d{4}\b/, // Years: 2023, 2022
+        /\b\d{1,2}\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\b/i, // Month dates
+        /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+\d{1,2}\b/i,
+        /\b\d{1,2}\/\d{1,2}\/\d{2,4}\b/, // Dates: 5/7/2023
+        /\b(yesterday|today|tomorrow|last week|last month|last year)\b/i,
+        /\b(\d+)\s+(day|week|month|year)s?\s+(ago|before)\b/i,
+    ];
+    const lower = content.toLowerCase();
+    return datePatterns.some(p => p.test(content) || p.test(lower));
+}
+/**
+ * Expand query for multi-session retrieval
+ */
+function expandQueryForMultiSession(query) {
+    const expansions = [query];
+    const lower = query.toLowerCase();
+    // Add time-based expansions
+    if (lower.includes('when')) {
+        expansions.push(query.replace(/when/i, '').trim());
+    }
+    if (lower.includes('before') || lower.includes('after')) {
+        expansions.push(query.replace(/before|after/i, '').trim());
+    }
+    if (lower.includes('earlier') || lower.includes('later')) {
+        expansions.push(query.replace(/earlier|later/i, '').trim());
+    }
+    // Add "mentioning" expansions for factual queries
+    if (lower.includes('what') || lower.includes('how')) {
+        expansions.push(query + ' mentioned');
+        expansions.push(query + ' said');
+    }
+    return [...new Set(expansions.filter(e => e.length > 2))];
+}
+/**
+ * Expand query for temporal retrieval - add date/temporal context
+ */
+function expandQueryForTemporal(query) {
+    const expansions = [query];
+    const lower = query.toLowerCase();
+    // For "when" questions, search with entity + date context
+    if (lower.includes('when')) {
+        // Extract entity name (everything after "when did" or "when is")
+        const entityMatch = query.match(/when\s+(?:did|is|was|were)\s+(\w+)/i);
+        if (entityMatch) {
+            const entity = entityMatch[1];
+            // Search with entity name alone (might match date mentions)
+            expansions.push(entity);
+            expansions.push(query.replace(/when\s+(?:did|is|was|were)\s+/i, '').trim());
+        }
+    }
+    // Add "date" and "time" expansions
+    if (lower.includes('when') || lower.includes('how long') || lower.includes('ago')) {
+        expansions.push(query + ' date');
+        expansions.push(query + ' time');
+    }
+    return [...new Set(expansions.filter(e => e.length > 2))];
+}
+/**
+ * Score with recency + similarity + entity boost (NO LLM required)
+ */
+function scoreWithHeuristics(result, query, now) {
+    let score = result.similarity ?? 0;
+    // 1. Recency boost: Recent = higher (up to +0.1)
+    if (result.createdAt) {
+        const created = new Date(result.createdAt).getTime();
+        const ageHours = (now - created) / (1000 * 60 * 60);
+        const recencyScore = Math.max(0, 0.1 * Math.exp(-ageHours / 720)); // Decay over 30 days
+        score += recencyScore;
+    }
+    // 2. Entity overlap: Query words appearing in content = boost
+    const queryWords = new Set(query.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+    const contentWords = new Set((result.content ?? "").toLowerCase().split(/\s+/));
+    const overlap = [...queryWords].filter(w => contentWords.has(w)).length;
+    score += overlap * 0.02; // Small boost per matching word
+    return score;
+}
+/**
+ * Main search function - vectors + graph boost + heuristics + places + sessions
+ * Unified search integrating Places, Graph, and Memory
  */
 export async function hybridSearch(input, options = {}) {
     const limit = options.limit ?? input.limit ?? 10;
-    const bm25Weight = options.bm25Weight ?? 0.5;
-    const vectorWeight = options.vectorWeight ?? 0.5;
-    // Run both searches in parallel
-    const [bm25Results, vectorResults] = await Promise.all([
-        bm25Search(input, { ...options, limit: limit * 2 }),
-        vectorSearch(input, { ...options, limit: limit * 2 }),
-    ]);
-    // Apply RRF to merge results
-    return reciprocalRankFusion(bm25Results, vectorResults, { limit, bm25Weight, vectorWeight });
+    const enableMultiSession = options.enableMultiSession !== false;
+    const enableHeuristics = options.enableHeuristics !== false;
+    const isMultiHop = enableMultiSession && isMultiSessionQuery(input.query);
+    const isTemporal = isTemporalQuery(input.query);
+    let vectorResults;
+    if (isMultiHop) {
+        // Multi-hop: use expansion to get more coverage
+        const expandedQueries = expandQueryForMultiSession(input.query);
+        const allResults = [];
+        for (const expQuery of expandedQueries) {
+            const expResults = await vectorSearch({ ...input, query: expQuery }, { ...options, limit: Math.ceil(limit * 2) });
+            allResults.push(...expResults);
+        }
+        const byId = new Map();
+        for (const r of allResults) {
+            const existing = byId.get(r.id);
+            if (!existing || (r.similarity ?? 0) > (existing.similarity ?? 0)) {
+                byId.set(r.id, r);
+            }
+        }
+        vectorResults = Array.from(byId.values());
+    }
+    else if (isTemporal) {
+        // Temporal: fetch more results
+        vectorResults = await vectorSearch(input, { ...options, limit: limit * 4 });
+    }
+    else {
+        // Regular query
+        vectorResults = await vectorSearch(input, { ...options, limit: limit * 2 });
+    }
+    // Task 2: Integrate Places into retrieval
+    // If placeId or placeType specified, filter/boost results from that place
+    if (input.placeId || input.placeType) {
+        vectorResults = await applyPlaceFilterAndBoost(vectorResults, input, limit);
+    }
+    // Task 3: Add session temporal scope
+    // If sessionId specified, boost memories from same session
+    if (input.sessionId) {
+        vectorResults = applySessionBoost(vectorResults, input.sessionId);
+    }
+    // TEMPORAL: Boost results with dates for temporal queries
+    if (isTemporal) {
+        vectorResults = applyTemporalBoost(vectorResults);
+    }
+    // Apply heuristics if enabled (recency + entity overlap)
+    if (enableHeuristics) {
+        const now = Date.now();
+        vectorResults = vectorResults.map(r => ({
+            ...r,
+            similarity: scoreWithHeuristics(r, input.query, now)
+        }));
+    }
+    // Graph boost
+    const graphWeight = config.scoringWeights.graphBoost;
+    const candidateIds = vectorResults.map(r => r.id);
+    const graphBoostMap = await computeGraphBoost(candidateIds);
+    let results = applyGraphBoostWithWeight(vectorResults, graphBoostMap, limit, graphWeight);
+    // Expand with associated memories for better coverage
+    if (options.includeAssociations !== false) {
+        results = await expandWithAssociations(results, limit);
+    }
+    // Task 4: Enable multi-hop graph traversal by default
+    // If query is detected as multi-hop, use actual graph traversal
+    if (isMultiHop && options.enableGraphTraversal !== false && input.project) {
+        try {
+            const graphResults = await multiHopSearch({
+                query: input.query,
+                project: input.project,
+                limit: limit,
+                includeVectorResults: false,
+                includeGraphResults: true,
+            });
+            // Merge graph results with vector results
+            const existingIds = new Set(results.map(r => r.id));
+            for (const gr of graphResults) {
+                if (!existingIds.has(gr.id)) {
+                    results.push({
+                        ...gr,
+                        similarity: (gr.similarity ?? 0) * 0.9 // Slightly lower weight
+                    });
+                }
+            }
+            // Re-sort
+            results.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+        }
+        catch (e) {
+            // Multi-hop failed, continue with vector results
+            logger.debug(`[HybridSearch] Multi-hop failed: ${e}`);
+        }
+    }
+    return results;
 }
 /**
- * BM25 keyword search using SQLite FTS5
+ * Task 2: Filter and boost results by place
  */
-async function bm25Search(input, options) {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const sqlite = db.$client;
-        const limit = options.limit ?? 10;
-        const tags = normalizeTags(options.tags ?? input.tags);
-        // Build FTS5 query with proper escaping
-        const ftsQuery = buildFtsQuery(input.query);
-        const isEmptyQuery = ftsQuery === '*';
-        // Build WHERE conditions
-        const conditions = [];
-        const params = [];
-        // For non-empty queries, use FTS5 MATCH
-        if (!isEmptyQuery) {
-            conditions.push('memories_fts MATCH ?');
-            params.push(ftsQuery);
+async function applyPlaceFilterAndBoost(results, input, limit) {
+    let placeIds = [];
+    // Get place IDs from placeId or placeType
+    if (input.placeType && input.project) {
+        const project = await requireProject(input.project);
+        const place = await getPlaceByType(project.id, input.placeType);
+        if (place) {
+            placeIds = [place.id];
         }
-        if (input.type) {
-            conditions.push('m.type = ?');
-            params.push(input.type);
+    }
+    else if (input.placeId) {
+        placeIds = [input.placeId];
+    }
+    if (placeIds.length === 0) {
+        return results;
+    }
+    // Get memories in this place
+    const placeMemories = new Set();
+    for (const pid of placeIds) {
+        const memIds = await getPlaceMemories(pid, limit * 3);
+        for (const mid of memIds) {
+            placeMemories.add(mid);
         }
-        if (tags.length) {
-            conditions.push('(' + tags.map(() => 'm.tags LIKE ?').join(' OR ') + ')');
-            params.push(...tags.map((tag) => `%${tag}%`));
+    }
+    // Boost memories from the specified place
+    const PLACE_BOOST = 0.15;
+    const boosted = results.map(r => {
+        if (placeMemories.has(r.id)) {
+            return {
+                ...r,
+                similarity: (r.similarity ?? 0) + PLACE_BOOST
+            };
         }
-        let projectId = null;
-        if (input.project) {
-            const project = await getProjectByPath(input.project);
-            if (project) {
-                projectId = project.id;
-                conditions.push('m.project_id = ?');
-                params.push(project.id);
+        return r;
+    });
+    // Re-sort with place boost
+    boosted.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+    return boosted;
+}
+/**
+ * Task 3: Boost memories from the same session (temporal)
+ */
+function applySessionBoost(results, sessionId) {
+    const SESSION_BOOST = 0.1;
+    const boosted = results.map(r => {
+        // Check if memory's session matches query's session
+        const memSession = r.metadata?.sessionMetadata?.sessionId;
+        if (memSession === sessionId) {
+            return {
+                ...r,
+                similarity: (r.similarity ?? 0) + SESSION_BOOST
+            };
+        }
+        return r;
+    });
+    // Re-sort with session boost
+    boosted.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+    return boosted;
+}
+/**
+ * TEMPORAL FIX: Boost memories that contain date references for "when" questions
+ * Also boost by date RECENCY - closer to today = higher for temporal queries
+ */
+function applyTemporalBoost(results) {
+    const TEMPORAL_BOOST = 0.25; // Moderate boost for date-containing memories
+    const boosted = results.map(r => {
+        let boost = 0;
+        // Boost 1: Has date reference - high priority for temporal
+        if (hasDateReference(r.content ?? "")) {
+            boost += TEMPORAL_BOOST;
+        }
+        return {
+            ...r,
+            similarity: (r.similarity ?? 0) + boost
+        };
+    });
+    // Re-sort with temporal boost
+    boosted.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+    return boosted;
+}
+/**
+ * MULTI-HOP FIX: Get memories from adjacent sessions using DB query
+ * This provides actual cross-session retrieval for multi-hop queries
+ */
+async function applySessionAdjacencyBoost(results, input, limit) {
+    if (!input.project)
+        return results;
+    // Extract session tags from top results
+    const sessionTags = new Set();
+    for (const r of results.slice(0, 5)) {
+        const sessionTag = extractSessionTag(r.tags);
+        if (sessionTag) {
+            sessionTags.add(sessionTag);
+        }
+    }
+    if (sessionTags.size === 0) {
+        return results;
+    }
+    // Get adjacent session tags
+    const adjacentSessionTags = new Set();
+    for (const tag of sessionTags) {
+        const adjacent = getAdjacentSessionTags(tag);
+        for (const adj of adjacent) {
+            adjacentSessionTags.add(adj);
+        }
+    }
+    if (adjacentSessionTags.size === 0) {
+        return results;
+    }
+    // Fetch memories from adjacent sessions
+    const project = await requireProject(input.project);
+    const adjacentMemories = [];
+    for (const sessionTag of adjacentSessionTags) {
+        const memories = await getMemoriesBySession(project.id, sessionTag, limit);
+        adjacentMemories.push(...memories);
+    }
+    if (adjacentMemories.length === 0) {
+        return results;
+    }
+    // Merge with boost
+    const existingIds = new Set(results.map(r => r.id));
+    const ADJACENT_BOOST = 0.3;
+    const merged = [...results];
+    for (const mem of adjacentMemories) {
+        if (!existingIds.has(mem.id)) {
+            merged.push({
+                ...mem,
+                similarity: (mem.similarity ?? 0) + ADJACENT_BOOST
+            });
+        }
+    }
+    // Re-sort
+    merged.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+    return merged.slice(0, limit * 2);
+}
+/**
+ * Expand results with directly associated memories
+ */
+async function expandWithAssociations(results, limit) {
+    const allIds = new Set(results.map(r => r.id));
+    const expanded = [...results];
+    // Get related for top results only
+    for (const r of results.slice(0, 3)) {
+        try {
+            const related = await getRelatedMemories(r.id, 5);
+            for (const rel of related) {
+                if (!allIds.has(rel.id)) {
+                    allIds.add(rel.id);
+                    expanded.push({
+                        ...rel,
+                        similarity: (rel.similarity ?? 0) * 0.8 // Slightly lower weight
+                    });
+                }
             }
         }
-        // For empty query with no filters, use "1=1" to match all
-        const whereClause = conditions.length > 0 ? conditions.join(' AND ') : '1=1';
-        // Build query based on whether we have a search term or not
-        const statement = sqlite.prepare(`
-      SELECT
-        m.id as id,
-        m.project_id as projectId,
-        m.type as type,
-        m.content as content,
-        m.summary as summary,
-        m.tags as tags,
-        m.metadata as metadata,
-        ${isEmptyQuery ? '0 as bm25Score' : 'bm25(memories_fts) as bm25Score'},
-        m.created_at as createdAt
-      FROM memories m
-      ${isEmptyQuery ? '' : 'INNER JOIN memories_fts ON m.rowid = memories_fts.rowid'}
-      WHERE ${whereClause}
-      ${isEmptyQuery ? 'ORDER BY m.created_at DESC' : 'ORDER BY bm25(memories_fts)'}
-      LIMIT ?
+        catch (e) {
+            // Skip errors
+        }
+    }
+    // Re-sort and return top results
+    expanded.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+    return expanded.slice(0, limit);
+}
+/**
+ * Get memories by session ID (stored in tags as "dialogue-1", "session-2", etc.)
+ */
+async function getMemoriesBySession(projectId, sessionTag, limit) {
+    try {
+        const db = createDatabaseClient(await getDb());
+        const sqlite = db.$client;
+        // Query memories where tags contain the session tag
+        const statement = sqlite.prepare(`
+      SELECT
+        m.id as id,
+        m.project_id as projectId,
+        m.type as type,
+        m.content as content,
+        m.summary as summary,
+        m.tags as tags,
+        m.metadata as metadata,
+        m.embedding as embedding,
+        m.embedding_json as embeddingJson,
+        m.created_at as createdAt
+      FROM memories m
+      WHERE m.project_id = ? AND m.tags LIKE ?
+      ORDER BY m.created_at DESC
+      LIMIT ?
     `);
-        const rows = statement.all(...params, limit * 3);
-        // Return as ranked results (lower BM25 score = better rank)
-        return rows.map((row, index) => ({
+        const rows = statement.all(projectId, `%${sessionTag}%`, limit);
+        return rows.map((row) => ({
             id: row.id,
-            rank: index + 1,
-            score: row.bm25Score,
-            result: {
-                id: row.id,
-                projectId: row.projectId,
-                type: row.type,
-                content: row.content,
-                summary: row.summary ?? undefined,
-                tags: fromSqliteTags(row.tags ?? null),
-                metadata: row.metadata ? JSON.parse(row.metadata) : null,
-                createdAt: row.createdAt ? new Date((Number(row.createdAt) || 0) * 1000).toISOString() : undefined,
-            },
+            projectId: row.projectId,
+            type: row.type,
+            content: row.content,
+            summary: row.summary ?? undefined,
+            tags: deserializeTags(row.tags ?? null),
+            metadata: deserializeMetadata(row.metadata ?? null),
+            createdAt: row.createdAt ? (normalizeTimestamp(Number(row.createdAt)) ?? undefined) : undefined,
+            similarity: 0.5, // Default similarity for fetched memories
         }));
     }
     catch (error) {
-        throw error;
+        logger.debug(`[HybridSearch] getMemoriesBySession failed: ${error}`);
+        return [];
+    }
+}
+/**
+ * Extract session tag from memory tags (e.g., "dialogue-1", "session_1", "D1", "D2")
+ */
+function extractSessionTag(tags) {
+    if (!tags)
+        return null;
+    // Look for patterns:
+    // - "dialogue-1", "dialogue_1", "dialogue1"
+    // - "session-2", "session_2", "session2"
+    // - "conv-1", "conv_1", "conv1"
+    // - "D1", "D2" (capital D followed by number)
+    for (const tag of tags) {
+        const lower = tag.toLowerCase();
+        if (/^(dialogue|session|conv|d)[_-]?\d+$/.test(lower)) {
+            return tag;
+        }
+    }
+    return null;
+}
+/**
+ * Get adjacent session tags (e.g., dialogue-1 -> dialogue-2, D1 -> D2)
+ */
+function getAdjacentSessionTags(currentTag) {
+    const adjacent = [];
+    // Pattern: dialogue-N, session-N, D-N, conv-N (with or without hyphen)
+    const match = currentTag.match(/^(.*?)(\d+)$/i);
+    if (match) {
+        const prefix = match[1];
+        const num = parseInt(match[2], 10);
+        // Adjacent: previous and next
+        if (num > 1) {
+            adjacent.push(`${prefix}${num - 1}`);
+        }
+        adjacent.push(`${prefix}${num + 1}`);
     }
+    return adjacent;
 }
 /**
  * Vector semantic search using cosine similarity
@@ -127,8 +483,6 @@ async function vectorSearch(input, options) {
         let queryEmbedding = null;
         if (!isEmptyQuery) {
             queryEmbedding = await getEmbedding(input.query);
-            // If embedding fails but query is not empty, still proceed without semantic ranking
-            // Fall back to recency-based ranking
         }
         // Build WHERE conditions
         const conditions = [];
@@ -143,52 +497,45 @@ async function vectorSearch(input, options) {
         }
         let projectId = null;
         if (input.project) {
-            const project = await getProjectByPath(input.project);
-            if (project) {
-                projectId = project.id;
-                conditions.push('m.project_id = ?');
-                params.push(project.id);
-            }
+            const project = await requireProject(input.project);
+            projectId = project.id;
+            conditions.push('m.project_id = ?');
+            params.push(project.id);
         }
         const whereClause = conditions.length > 0
             ? 'WHERE ' + conditions.join(' AND ')
             : '';
         // Fetch candidates for vector search
-        const statement = sqlite.prepare(`
-      SELECT
-        m.id as id,
-        m.project_id as projectId,
-        m.type as type,
-        m.content as content,
-        m.summary as summary,
-        m.tags as tags,
-        m.metadata as metadata,
-        m.embedding as embedding,
-        m.embedding_json as embeddingJson,
-        m.created_at as createdAt
-      FROM memories m
-      ${whereClause}
-      ORDER BY m.created_at DESC
-      LIMIT ?
+        const statement = sqlite.prepare(`
+      SELECT
+        m.id as id,
+        m.project_id as projectId,
+        m.type as type,
+        m.content as content,
+        m.summary as summary,
+        m.tags as tags,
+        m.metadata as metadata,
+        m.embedding as embedding,
+        m.embedding_json as embeddingJson,
+        m.created_at as createdAt
+      FROM memories m
+      ${whereClause}
+      ORDER BY m.created_at DESC
+      LIMIT ?
     `);
         const rows = statement.all(...params, limit * 3);
         // If no embedding available, return results ordered by recency
         if (!queryEmbedding) {
-            return rows.slice(0, limit * 2).map((item, index) => ({
+            return rows.slice(0, limit * 2).map((item) => ({
                 id: item.id,
-                rank: index + 1,
-                score: 0, // No similarity score available
-                result: {
-                    id: item.id,
-                    projectId: item.projectId,
-                    type: item.type,
-                    content: item.content,
-                    summary: item.summary ?? undefined,
-                    tags: fromSqliteTags(item.tags ?? null),
-                    metadata: item.metadata ? JSON.parse(item.metadata) : null,
-                    createdAt: item.createdAt ? new Date((Number(item.createdAt) || 0) * 1000).toISOString() : undefined,
-                    similarity: 0,
-                },
+                projectId: item.projectId,
+                type: item.type,
+                content: item.content,
+                summary: item.summary ?? undefined,
+                tags: deserializeTags(item.tags ?? null),
+                metadata: deserializeMetadata(item.metadata ?? null),
+                createdAt: item.createdAt ? (normalizeTimestamp(Number(item.createdAt)) ?? undefined) : undefined,
+                similarity: 0,
             }));
         }
         // Calculate cosine similarity for each result
@@ -211,23 +558,18 @@ async function vectorSearch(input, options) {
             };
         })
             .filter((item) => item !== null);
-        // Sort by similarity (descending) and return as ranked results
+        // Sort by similarity (descending) and return
         scored.sort((a, b) => b.similarity - a.similarity);
-        return scored.slice(0, limit * 2).map((item, index) => ({
+        return scored.slice(0, limit * 2).map((item) => ({
             id: item.id,
-            rank: index + 1,
-            score: item.similarity,
-            result: {
-                id: item.id,
-                projectId: item.projectId,
-                type: item.type,
-                content: item.content,
-                summary: item.summary ?? undefined,
-                tags: fromSqliteTags(item.tags ?? null),
-                metadata: item.metadata ? JSON.parse(item.metadata) : null,
-                createdAt: item.createdAt ? new Date((Number(item.createdAt) || 0) * 1000).toISOString() : undefined,
-                similarity: item.similarity,
-            },
+            projectId: item.projectId,
+            type: item.type,
+            content: item.content,
+            summary: item.summary ?? undefined,
+            tags: deserializeTags(item.tags ?? null),
+            metadata: deserializeMetadata(item.metadata ?? null),
+            createdAt: item.createdAt ? (normalizeTimestamp(Number(item.createdAt)) ?? undefined) : undefined,
+            similarity: item.similarity,
         }));
     }
     catch (error) {
@@ -235,139 +577,20 @@ async function vectorSearch(input, options) {
     }
 }
 /**
- * Reciprocal Rank Fusion (RRF) - merges ranked lists without score calibration
- *
- * RRF Formula: score(item) = sum(weight_i / (k + rank_i))
- * Where k is a constant (typically 60) that prevents high ranks from dominating
- *
- * Benefits:
- * - No need to calibrate different scoring systems (BM25 vs cosine similarity)
- * - Handles items that appear in only one list
- * - Proven to outperform weighted score fusion in most cases
- */
-function reciprocalRankFusion(bm25Results, vectorResults, options) {
-    const { limit, bm25Weight, vectorWeight } = options;
-    const scores = new Map();
-    // Process BM25 results
-    for (const item of bm25Results) {
-        const rrfScore = (bm25Weight * 2) / (RRF_K + item.rank);
-        const existing = scores.get(item.id);
-        if (existing) {
-            existing.score += rrfScore;
-        }
-        else {
-            scores.set(item.id, { score: rrfScore, result: item.result });
-        }
-    }
-    // Process vector results
-    for (const item of vectorResults) {
-        const rrfScore = (vectorWeight * 2) / (RRF_K + item.rank);
-        const existing = scores.get(item.id);
-        if (existing) {
-            existing.score += rrfScore;
-        }
-        else {
-            scores.set(item.id, { score: rrfScore, result: item.result });
-        }
-    }
-    // Sort by RRF score (descending) and return top results
-    return Array.from(scores.values())
-        .sort((a, b) => b.score - a.score)
-        .slice(0, limit)
-        .map((item) => ({
-        ...item.result,
-        similarity: item.result.similarity ?? 0,
-    }));
-}
-/**
- * Build FTS5 query string from user input
- * Handles phrase searches, OR operators for better recall, and special characters
+ * Apply small graph boost to results
+ * Graph boost is ADDITIVE (not dominating)
  */
-function buildFtsQuery(query) {
-    // Ensure query is a string
-    const queryString = typeof query === 'string' ? query : String(query ?? '');
-    // Remove special characters that could break FTS5 syntax (except quotes)
-    // Hyphens are problematic in FTS5 - they're treated as exclusion operators
-    let cleaned = queryString.replace(/[^\w\s"'-]/g, ' ');
-    // If query contains quotes, preserve as phrase search
-    if (cleaned.includes('"')) {
-        return cleaned || '*'; // Return * for empty after cleaning
-    }
-    // Split into terms
-    const terms = cleaned.trim().split(/\s+/).filter((t) => t.length > 0);
-    if (terms.length === 0) {
-        return '*'; // Match all for empty query
-    }
-    // Wrap terms containing hyphens in quotes (e.g., "trash-cli" prevents hyphen being interpreted as NOT)
-    const processedTerms = terms.map(term => {
-        if (term.includes('-')) {
-            return `"${term}"`;
-        }
-        return term;
+function applyGraphBoostWithWeight(results, graphBoostMap, limit, graphWeight) {
+    // Apply SMALL additive boost to each result
+    // graphWeight should be 0.1-0.3, not > 1
+    const boosted = results.map(result => {
+        const boost = graphBoostMap[result.id] ?? 0;
+        // Add small nudge, don't replace similarity
+        const boostedSimilarity = (result.similarity ?? 0) + (boost * graphWeight);
+        return { ...result, similarity: boostedSimilarity };
     });
-    // For multi-word queries, use OR for better recall (any term matches)
-    // This is less restrictive than AND and finds more relevant results
-    if (processedTerms.length > 1) {
-        return processedTerms.join(' OR ');
-    }
-    return processedTerms[0];
-}
-/**
- * Parse embedding from SQLite storage
- */
-function parseEmbedding(embeddingData) {
-    if (!embeddingData)
-        return null;
-    if (Array.isArray(embeddingData))
-        return embeddingData;
-    if (embeddingData instanceof Uint8Array || Buffer.isBuffer(embeddingData)) {
-        try {
-            const json = JSON.parse(embeddingData.toString());
-            if (Array.isArray(json))
-                return json;
-        }
-        catch {
-            try {
-                const buffer = embeddingData.buffer;
-                const arrayBuffer = buffer instanceof ArrayBuffer
-                    ? buffer
-                    : buffer;
-                const floatArray = new Float32Array(arrayBuffer);
-                return Array.from(floatArray);
-            }
-            catch {
-                return null;
-            }
-        }
-    }
-    if (typeof embeddingData === 'string') {
-        try {
-            const parsed = JSON.parse(embeddingData);
-            if (Array.isArray(parsed))
-                return parsed;
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-/**
- * Calculate cosine similarity between two vectors
- */
-function cosineSimilarity(a, b) {
-    if (a.length !== b.length)
-        return 0;
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    if (normA === 0 || normB === 0)
-        return 0;
-    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    // Re-sort by boosted similarity
+    boosted.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+    return boosted.slice(0, limit);
 }
 //# sourceMappingURL=hybrid-search.js.map