context-mode 1.0.24 → 1.0.26

package/build/store.js

@@ -116,6 +116,52 @@ export function cleanupStaleDBs() {
     catch { /* ignore readdir errors */ }
     return cleaned;
 }
+// ── Proximity helpers (pure functions) ──
+/** Find all positions of a term in text. */
+function findAllPositions(text, term) {
+    const positions = [];
+    let idx = text.indexOf(term);
+    while (idx !== -1) {
+        positions.push(idx);
+        idx = text.indexOf(term, idx + 1);
+    }
+    return positions;
+}
+/**
+ * Find minimum span (window) covering at least one position from each list.
+ * Uses a sweep-line approach: advance the pointer at the current minimum.
+ */
+function findMinSpan(positionLists) {
+    if (positionLists.length === 0)
+        return Infinity;
+    if (positionLists.length === 1)
+        return 0;
+    const sorted = positionLists.map((p) => [...p].sort((a, b) => a - b));
+    const ptrs = new Array(sorted.length).fill(0);
+    let minSpan = Infinity;
+    while (true) {
+        let curMin = Infinity;
+        let curMax = -Infinity;
+        let minIdx = 0;
+        for (let i = 0; i < sorted.length; i++) {
+            const val = sorted[i][ptrs[i]];
+            if (val < curMin) {
+                curMin = val;
+                minIdx = i;
+            }
+            if (val > curMax) {
+                curMax = val;
+            }
+        }
+        const span = curMax - curMin;
+        if (span < minSpan)
+            minSpan = span;
+        ptrs[minIdx]++;
+        if (ptrs[minIdx] >= sorted[minIdx].length)
+            break;
+    }
+    return minSpan;
+}
 export class ContentStore {
     #db;
     #dbPath;
@@ -138,6 +184,10 @@ export class ContentStore {
     #stmtSearchTrigram;
     #stmtSearchTrigramFiltered;
     #stmtFuzzyVocab;
+    #stmtSearchPorterContentType;
+    #stmtSearchPorterFilteredContentType;
+    #stmtSearchTrigramContentType;
+    #stmtSearchTrigramFilteredContentType;
     // Read path
     #stmtListSources;
     #stmtChunksBySource;
@@ -217,7 +267,7 @@ export class ContentStore {
         chunks.content,
         chunks.content_type,
         sources.label,
-        bm25(chunks, 2.0, 1.0) AS rank,
+        bm25(chunks, 5.0, 1.0) AS rank,
         highlight(chunks, 1, char(2), char(3)) AS highlighted
       FROM chunks
       JOIN sources ON sources.id = chunks.source_id
@@ -231,7 +281,7 @@ export class ContentStore {
         chunks.content,
         chunks.content_type,
         sources.label,
-        bm25(chunks, 2.0, 1.0) AS rank,
+        bm25(chunks, 5.0, 1.0) AS rank,
         highlight(chunks, 1, char(2), char(3)) AS highlighted
       FROM chunks
       JOIN sources ON sources.id = chunks.source_id
@@ -245,7 +295,7 @@ export class ContentStore {
         chunks_trigram.content,
         chunks_trigram.content_type,
         sources.label,
-        bm25(chunks_trigram, 2.0, 1.0) AS rank,
+        bm25(chunks_trigram, 5.0, 1.0) AS rank,
         highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
       FROM chunks_trigram
       JOIN sources ON sources.id = chunks_trigram.source_id
@@ -259,13 +309,70 @@ export class ContentStore {
         chunks_trigram.content,
         chunks_trigram.content_type,
         sources.label,
-        bm25(chunks_trigram, 2.0, 1.0) AS rank,
+        bm25(chunks_trigram, 5.0, 1.0) AS rank,
         highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
       FROM chunks_trigram
       JOIN sources ON sources.id = chunks_trigram.source_id
       WHERE chunks_trigram MATCH ? AND sources.label LIKE ?
       ORDER BY rank
       LIMIT ?
+    `);
+        // Content-type filtered variants
+        this.#stmtSearchPorterContentType = this.#db.prepare(`
+      SELECT
+        chunks.title,
+        chunks.content,
+        chunks.content_type,
+        sources.label,
+        bm25(chunks, 5.0, 1.0) AS rank,
+        highlight(chunks, 1, char(2), char(3)) AS highlighted
+      FROM chunks
+      JOIN sources ON sources.id = chunks.source_id
+      WHERE chunks MATCH ? AND chunks.content_type = ?
+      ORDER BY rank
+      LIMIT ?
+    `);
+        this.#stmtSearchPorterFilteredContentType = this.#db.prepare(`
+      SELECT
+        chunks.title,
+        chunks.content,
+        chunks.content_type,
+        sources.label,
+        bm25(chunks, 5.0, 1.0) AS rank,
+        highlight(chunks, 1, char(2), char(3)) AS highlighted
+      FROM chunks
+      JOIN sources ON sources.id = chunks.source_id
+      WHERE chunks MATCH ? AND sources.label LIKE ? AND chunks.content_type = ?
+      ORDER BY rank
+      LIMIT ?
+    `);
+        this.#stmtSearchTrigramContentType = this.#db.prepare(`
+      SELECT
+        chunks_trigram.title,
+        chunks_trigram.content,
+        chunks_trigram.content_type,
+        sources.label,
+        bm25(chunks_trigram, 5.0, 1.0) AS rank,
+        highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
+      FROM chunks_trigram
+      JOIN sources ON sources.id = chunks_trigram.source_id
+      WHERE chunks_trigram MATCH ? AND chunks_trigram.content_type = ?
+      ORDER BY rank
+      LIMIT ?
+    `);
+        this.#stmtSearchTrigramFilteredContentType = this.#db.prepare(`
+      SELECT
+        chunks_trigram.title,
+        chunks_trigram.content,
+        chunks_trigram.content_type,
+        sources.label,
+        bm25(chunks_trigram, 5.0, 1.0) AS rank,
+        highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
+      FROM chunks_trigram
+      JOIN sources ON sources.id = chunks_trigram.source_id
+      WHERE chunks_trigram MATCH ? AND sources.label LIKE ? AND chunks_trigram.content_type = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         // Fuzzy path
         this.#stmtFuzzyVocab = this.#db.prepare("SELECT word FROM vocabulary WHERE length(word) BETWEEN ? AND ?");
@@ -374,14 +481,26 @@ export class ContentStore {
         };
     }
     // ── Search ──
-    search(query, limit = 3, source, mode = "AND") {
+    search(query, limit = 3, source, mode = "AND", contentType) {
         const sanitized = sanitizeQuery(query, mode);
-        const stmt = source
-            ? this.#stmtSearchPorterFiltered
-            : this.#stmtSearchPorter;
-        const params = source
-            ? [sanitized, `%${source}%`, limit]
-            : [sanitized, limit];
+        let stmt;
+        let params;
+        if (source && contentType) {
+            stmt = this.#stmtSearchPorterFilteredContentType;
+            params = [sanitized, `%${source}%`, contentType, limit];
+        }
+        else if (source) {
+            stmt = this.#stmtSearchPorterFiltered;
+            params = [sanitized, `%${source}%`, limit];
+        }
+        else if (contentType) {
+            stmt = this.#stmtSearchPorterContentType;
+            params = [sanitized, contentType, limit];
+        }
+        else {
+            stmt = this.#stmtSearchPorter;
+            params = [sanitized, limit];
+        }
         const rows = stmt.all(...params);
         return rows.map((r) => ({
             title: r.title,
@@ -393,16 +512,28 @@ export class ContentStore {
         }));
     }
     // ── Trigram Search (Layer 2) ──
-    searchTrigram(query, limit = 3, source, mode = "AND") {
+    searchTrigram(query, limit = 3, source, mode = "AND", contentType) {
         const sanitized = sanitizeTrigramQuery(query, mode);
         if (!sanitized)
             return [];
-        const stmt = source
-            ? this.#stmtSearchTrigramFiltered
-            : this.#stmtSearchTrigram;
-        const params = source
-            ? [sanitized, `%${source}%`, limit]
-            : [sanitized, limit];
+        let stmt;
+        let params;
+        if (source && contentType) {
+            stmt = this.#stmtSearchTrigramFilteredContentType;
+            params = [sanitized, `%${source}%`, contentType, limit];
+        }
+        else if (source) {
+            stmt = this.#stmtSearchTrigramFiltered;
+            params = [sanitized, `%${source}%`, limit];
+        }
+        else if (contentType) {
+            stmt = this.#stmtSearchTrigramContentType;
+            params = [sanitized, contentType, limit];
+        }
+        else {
+            stmt = this.#stmtSearchTrigram;
+            params = [sanitized, limit];
+        }
         const rows = stmt.all(...params);
         return rows.map((r) => ({
             title: r.title,
@@ -433,35 +564,72 @@ export class ContentStore {
         }
         return bestDist <= maxDist ? bestWord : null;
     }
+    // ── Reciprocal Rank Fusion (Cormack et al. 2009) ──
+    #rrfSearch(query, limit, source, contentType) {
+        const K = 60; // Standard RRF constant
+        const fetchLimit = Math.max(limit * 2, 10);
+        const porterResults = this.search(query, fetchLimit, source, "OR", contentType);
+        const trigramResults = this.searchTrigram(query, fetchLimit, source, "OR", contentType);
+        const scoreMap = new Map();
+        const key = (r) => `${r.source}::${r.title}`;
+        for (const [i, r] of porterResults.entries()) {
+            const k = key(r);
+            const existing = scoreMap.get(k);
+            if (existing) {
+                existing.score += 1 / (K + i + 1);
+            }
+            else {
+                scoreMap.set(k, { result: r, score: 1 / (K + i + 1) });
+            }
+        }
+        for (const [i, r] of trigramResults.entries()) {
+            const k = key(r);
+            const existing = scoreMap.get(k);
+            if (existing) {
+                existing.score += 1 / (K + i + 1);
+            }
+            else {
+                scoreMap.set(k, { result: r, score: 1 / (K + i + 1) });
+            }
+        }
+        return Array.from(scoreMap.values())
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map(({ result, score }) => ({ ...result, rank: -score }));
+    }
+    // ── Proximity Reranking ──
+    #applyProximityReranking(results, query) {
+        const terms = query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((w) => w.length >= 2);
+        // Single-term queries: no reranking needed
+        if (terms.length < 2)
+            return results;
+        return results
+            .map((r) => {
+            const content = r.content.toLowerCase();
+            const positions = terms.map((t) => findAllPositions(content, t));
+            // If any term is missing from content, no proximity boost
+            if (positions.some((p) => p.length === 0)) {
+                return { result: r, boost: 0 };
+            }
+            const minSpan = findMinSpan(positions);
+            const boost = 1 / (1 + minSpan / Math.max(content.length, 1));
+            return { result: r, boost };
+        })
+            .sort((a, b) => b.boost - a.boost || a.result.rank - b.result.rank)
+            .map(({ result }) => result);
+    }
     // ── Unified Fallback Search ──
-    searchWithFallback(query, limit = 3, source) {
-        // Layer 1a: Porter + AND (most precise)
-        const porterAnd = this.search(query, limit, source, "AND");
-        if (porterAnd.length > 0) {
-            return porterAnd.map((r) => ({ ...r, matchLayer: "porter" }));
-        }
-        // Layer 1b: Porter + OR (fallback when AND finds nothing)
-        const porterOr = this.search(query, limit, source, "OR");
-        if (porterOr.length > 0) {
-            return porterOr.map((r) => ({ ...r, matchLayer: "porter" }));
-        }
-        // Layer 2a: Trigram + AND
-        const trigramAnd = this.searchTrigram(query, limit, source, "AND");
-        if (trigramAnd.length > 0) {
-            return trigramAnd.map((r) => ({
-                ...r,
-                matchLayer: "trigram",
-            }));
-        }
-        // Layer 2b: Trigram + OR
-        const trigramOr = this.searchTrigram(query, limit, source, "OR");
-        if (trigramOr.length > 0) {
-            return trigramOr.map((r) => ({
-                ...r,
-                matchLayer: "trigram",
-            }));
-        }
-        // Layer 3: Fuzzy correction + re-search (AND then OR)
+    searchWithFallback(query, limit = 3, source, contentType) {
+        // Step 1: RRF fusion (porter OR + trigram OR → merge)
+        const rrfResults = this.#rrfSearch(query, limit, source, contentType);
+        if (rrfResults.length > 0) {
+            const reranked = this.#applyProximityReranking(rrfResults, query);
+            return reranked.map((r) => ({ ...r, matchLayer: "rrf" }));
+        }
+        // Step 2: Fuzzy correction → RRF re-run
         const words = query
             .toLowerCase()
             .trim()
@@ -471,21 +639,10 @@ export class ContentStore {
         const correctedWords = words.map((w) => this.fuzzyCorrect(w) ?? w);
         const correctedQuery = correctedWords.join(" ");
         if (correctedQuery !== original) {
-            const fuzzyPorterAnd = this.search(correctedQuery, limit, source, "AND");
-            if (fuzzyPorterAnd.length > 0) {
-                return fuzzyPorterAnd.map((r) => ({ ...r, matchLayer: "fuzzy" }));
-            }
-            const fuzzyPorterOr = this.search(correctedQuery, limit, source, "OR");
-            if (fuzzyPorterOr.length > 0) {
-                return fuzzyPorterOr.map((r) => ({ ...r, matchLayer: "fuzzy" }));
-            }
-            const fuzzyTrigramAnd = this.searchTrigram(correctedQuery, limit, source, "AND");
-            if (fuzzyTrigramAnd.length > 0) {
-                return fuzzyTrigramAnd.map((r) => ({ ...r, matchLayer: "fuzzy" }));
-            }
-            const fuzzyTrigramOr = this.searchTrigram(correctedQuery, limit, source, "OR");
-            if (fuzzyTrigramOr.length > 0) {
-                return fuzzyTrigramOr.map((r) => ({ ...r, matchLayer: "fuzzy" }));
+            const fuzzyResults = this.#rrfSearch(correctedQuery, limit, source, contentType);
+            if (fuzzyResults.length > 0) {
+                const reranked = this.#applyProximityReranking(fuzzyResults, correctedQuery);
+                return reranked.map((r) => ({ ...r, matchLayer: "rrf-fuzzy" }));
             }
         }
         return [];

package/build/types.d.ts

@@ -64,7 +64,7 @@ export interface SearchResult {
     source: string;
     rank: number;
     contentType: "code" | "prose";
-    matchLayer?: "porter" | "trigram" | "fuzzy";
+    matchLayer?: "porter" | "trigram" | "fuzzy" | "rrf" | "rrf-fuzzy";
     highlighted?: string;
 }
 /**