opencode-memory-pro 1.4.1 → 1.4.2

package/README.md

@@ -40,7 +40,7 @@ Published on npm — install directly (requires OpenCode ≥ 1.x and Node.js ≥
 opencode plugin opencode-memory-pro
 ```
 
-The latest release is **v1.4.0** on [npm](https://www.npmjs.com/package/opencode-memory-pro); source and releases are on [GitHub](https://github.com/tman204-50/opencode-memory-pro).
+The latest release is on [npm](https://www.npmjs.com/package/opencode-memory-pro); source and releases are on [GitHub](https://github.com/tman204-50/opencode-memory-pro).
 
 ### Getting started
 
@@ -175,9 +175,11 @@ index and capture still works — the plugin is offline-tolerant by design.
 
 | Key | Default | Description |
 |---|---|---|
-| `retrieval.mode` | `"hybrid"` | `"hybrid"` (vector+BM25 RRF) or `"vector"`. |
-| `retrieval.vectorWeight` | `0.7` | Vector/BM25 ratio before normalization. |
+| `retrieval.mode` | `"hybrid"` | `"hybrid"` (vector+BM25+fuzzy RRF) or `"vector"`. |
+| `retrieval.vectorWeight` | `0.7` | Vector/BM25/fuzzy ratio before normalization. |
 | `retrieval.bm25Weight` | `0.3` | (Weights are normalized to sum 1.) |
+| `retrieval.fuzzyWeight` | `0.15` | fuse.js typo-tolerant fuzzy channel weight; `0` disables it. |
+| `retrieval.fuzzyThreshold` | `0.5` | fuse.js match threshold (lower = stricter). |
 | `retrieval.minScore` | `0.2` | Minimum score for a result to qualify. |
 | `retrieval.rrfK` | `60` | RRF constant. |
 | `retrieval.recencyBoost` | `true` | Boost recently recalled/created memories. |
@@ -186,9 +188,34 @@ index and capture still works — the plugin is offline-tolerant by design.
 | `retrieval.feedbackWeight` | `0.3` | Weight of feedback history in scoring (0–1). |
 
 Env: `OPENCODE_MEMORY_PRO_RETRIEVAL_MODE`, `..._VECTOR_WEIGHT`,
-`..._BM25_WEIGHT`, `..._MIN_SCORE`, `..._RRF_K`, `..._RECENCY_BOOST`,
+`..._BM25_WEIGHT`, `..._FUZZY_WEIGHT`, `..._FUZZY_THRESHOLD`, `..._MIN_SCORE`,
+`..._RRF_K`, `..._RECENCY_BOOST`,
 `..._RECENCY_HALF_LIFE_HOURS`, `..._IMPORTANCE_WEIGHT`, `..._FEEDBACK_WEIGHT`.
 
+## Changelog
+
+### v1.4.2 (2026-09-06)
+
+New **fuzzy search channel** — fuse.js joins the RRF merge as a third
+retrieval channel alongside vector and BM25, giving typo-tolerant matching
+out of the box:
+
+- **Typo tolerance**: `memory_search "lancedb vectr srch"` now surfaces the
+  right memory even when vector and BM25 both miss — useful for queries with
+  misspellings, partial words, or accented text (`ignoreDiacritics`).
+- **Zero-config**: `retrieval.fuzzyWeight` defaults to `0.15` (renormalized
+  with vector/BM25); set it to `0` to restore pre-1.4.2 scores exactly.
+- **Channel semantics**: records that don't appear in the fuzzy top-N
+  contribute no RRF rank, same as the other channels; `fuzzyThreshold`
+  (default `0.5`) drops weak matches.
+- **Fallback-aware**: the fuzzy channel stays active in the BM25-only
+  fallback (embedder unavailable) — that's exactly when typo tolerance helps
+  most — and is disabled only in explicit `retrieval.mode = "vector"`.
+- **Index lifecycle**: fuse.js index is built lazily over the scope cache,
+  reused across single-scope searches, and rebuilt automatically on cache
+  invalidation or threshold change.
+- `memory_stats` now reports the fuzzy channel (`enabled`/`weight`/`threshold`).
+
 ### Injection
 
 How memories are injected into the model context.

package/dist/config.js

@@ -18,9 +18,14 @@ export function resolveMemoryConfig(config, worktree) {
     const dbPath = expandHomePath(firstString(process.env.OPENCODE_MEMORY_PRO_DB_PATH, raw.dbPath) ?? DEFAULT_DB_PATH);
     const vectorWeight = clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_VECTOR_WEIGHT ?? retrievalRaw.vectorWeight, 0.7), 0, 1);
     const bm25Weight = clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_BM25_WEIGHT ?? retrievalRaw.bm25Weight, 0.3), 0, 1);
-    const weightSum = vectorWeight + bm25Weight;
+    // FUZZY_CHANNEL (1.4.2): fuse.js fuzzy-match channel participates in the
+    // RRF merge alongside vector + BM25. Weight 0 disables it entirely.
+    const fuzzyWeight = clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_FUZZY_WEIGHT ?? retrievalRaw.fuzzyWeight, 0.15), 0, 1);
+    const fuzzyThreshold = clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_FUZZY_THRESHOLD ?? retrievalRaw.fuzzyThreshold, 0.5), 0, 1);
+    const weightSum = vectorWeight + bm25Weight + fuzzyWeight;
     const normalizedVectorWeight = weightSum > 0 ? vectorWeight / weightSum : 0.7;
     const normalizedBm25Weight = weightSum > 0 ? bm25Weight / weightSum : 0.3;
+    const normalizedFuzzyWeight = weightSum > 0 ? fuzzyWeight / weightSum : 0;
     const rrfK = Math.max(1, Math.floor(toNumber(process.env.OPENCODE_MEMORY_PRO_RRF_K ?? retrievalRaw.rrfK, 60)));
     const recencyBoost = toBoolean(process.env.OPENCODE_MEMORY_PRO_RECENCY_BOOST ?? retrievalRaw.recencyBoost, true);
     const recencyHalfLifeHours = Math.max(1, toNumber(process.env.OPENCODE_MEMORY_PRO_RECENCY_HALF_LIFE_HOURS ?? retrievalRaw.recencyHalfLifeHours, 72));
@@ -74,6 +79,8 @@ export function resolveMemoryConfig(config, worktree) {
             mode,
             vectorWeight: normalizedVectorWeight,
             bm25Weight: normalizedBm25Weight,
+            fuzzyWeight: normalizedFuzzyWeight,
+            fuzzyThreshold,
             minScore: clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_MIN_SCORE ?? retrievalRaw.minScore, 0.2), 0, 1),
             rrfK,
             recencyBoost,

package/dist/index.js

@@ -11,7 +11,7 @@ import { requestLLMCapture, isOwnSession } from "./llm.js";
 import { createMemoryTools, createFeedbackTools, createEpisodicTools } from "./tools/index.js";
 import { sweepExpiredMemories } from "./tools/memory.js";
 import { createGraphStore } from "./graph.js";
-const PLUGIN_VERSION = "1.4.1";
+const PLUGIN_VERSION = "1.4.2";
 const SCHEMA_VERSION = 1;
 // Event-driven dedup: run consolidateDuplicates on session.idle (throttled to
 // this interval so chatty sessions aren't re-scanning the store every turn)

package/dist/store.d.ts

@@ -40,6 +40,8 @@ export declare class MemoryStore {
         limit: number;
         vectorWeight: number;
         bm25Weight: number;
+        fuzzyWeight?: number;
+        fuzzyThreshold?: number;
         minScore: number;
         rrfK?: number;
         recencyBoost?: boolean;

package/dist/store.js

@@ -1,5 +1,6 @@
 import { mkdir, open, readFile, readdir, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import Fuse from "fuse.js";
 import { validateEpisodicRecord, validateEpisodicRecordArray } from "./types.js";
 import { tokenize } from "./utils.js";
 import { log, logFileOnly } from "./logger.js";
@@ -588,13 +589,21 @@ export class MemoryStore {
         const queryNorm = vecNorm(params.queryVector);
         const useVectorChannel = params.queryVector.length > 0 && params.vectorWeight > 0;
         const useBm25Channel = queryTokens.length > 0 && params.bm25Weight > 0;
-        const { vectorWeight, bm25Weight } = normalizeChannelWeights(useVectorChannel ? params.vectorWeight : 0, useBm25Channel ? params.bm25Weight : 0);
+        // FUZZY_CHANNEL (1.4.2): fuse.js typo-tolerant channel. On by default
+        // (weight 0.15) unless the caller passes fuzzyWeight 0.
+        const fuzzyWeight = Math.max(0, Number(params.fuzzyWeight) || 0);
+        const useFuzzyChannel = params.query.trim().length > 0 && fuzzyWeight > 0;
+        const fuzzyThreshold = params.fuzzyThreshold !== undefined ? Math.max(0, Math.min(1, params.fuzzyThreshold)) : 0.5;
+        const { vectorWeight, bm25Weight, fuzzyWeight: normalizedFuzzyWeight } = normalizeChannelWeights(useVectorChannel ? params.vectorWeight : 0, useBm25Channel ? params.bm25Weight : 0, useFuzzyChannel ? fuzzyWeight : 0);
         const rrfK = Math.max(1, Math.floor(params.rrfK ?? 60));
         const recencyBoostEnabled = params.recencyBoost ?? true;
         const recencyHalfLifeHours = Math.max(1, params.recencyHalfLifeHours ?? 72);
         const importanceWeight = clampImportanceWeight(params.importanceWeight ?? 0.4);
         const feedbackWeight = Math.max(0, Math.min(1, params.feedbackWeight ?? 0));
         const globalDiscountFactor = params.globalDiscountFactor ?? 1.0;
+        const fuzzyResults = useFuzzyChannel ? this.getFuzzyIndex(cached, params.scopes, fuzzyThreshold).search(params.query.trim(), { limit: Math.max(50, params.limit * 4) }) : [];
+        const fuzzyRanks = useFuzzyChannel ? buildRankMap(fuzzyResults.map((r) => ({ record: r.item, fuzzyScore: 1 - (r.score ?? 1) })), (item) => item.fuzzyScore) : null;
+        const fuzzyScoreMap = new Map(fuzzyResults.map((r) => [r.item.id, 1 - (r.score ?? 1)]));
         const candidates = cached.records
             .filter((record) => params.queryVector.length === 0 || record.vector.length === params.queryVector.length)
             .map((record, index) => {
@@ -602,7 +611,7 @@ export class MemoryStore {
             const vectorScore = useVectorChannel ? fastCosine(params.queryVector, record.vector, queryNorm, recordNorm) : 0;
             const bm25Score = useBm25Channel ? bm25LikeScore(queryTokens, cached.tokenized[index], cached.idf) : 0;
             const isGlobal = record.scope === "global";
-            return { record, vectorScore, bm25Score, isGlobal };
+            return { record, vectorScore, bm25Score, fuzzyScore: fuzzyScoreMap.get(record.id) ?? 0, isGlobal };
         });
         if (candidates.length === 0)
             return [];
@@ -624,6 +633,14 @@ export class MemoryStore {
                 if (rank !== undefined)
                     rrfScore += bm25Weight / (rrfK + rank);
             }
+            // FUZZY_CHANNEL (1.4.2): only records that appear in the fuzzy
+            // top-N contribute a rank; the rest get nothing (same semantics
+            // as the other channels).
+            if (fuzzyRanks) {
+                const rank = fuzzyRanks.get(item.record.id);
+                if (rank !== undefined)
+                    rrfScore += normalizedFuzzyWeight / (rrfK + rank);
+            }
             rrfScore *= rrfK + 1;
             const recencyFactor = recencyBoostEnabled
                 ? computeRecencyMultiplier(item.record.timestamp, recencyHalfLifeHours)
@@ -640,6 +657,7 @@ export class MemoryStore {
                 score,
                 vectorScore: item.vectorScore,
                 bm25Score: item.bm25Score,
+                fuzzyScore: item.fuzzyScore,
             };
         })
             .filter((item) => item.score >= params.minScore)
@@ -1802,7 +1820,34 @@ export class MemoryStore {
         const idf = scopes.length === 1 && this.scopeCache.has(scopes[0])
             ? this.scopeCache.get(scopes[0]).idf
             : computeIdf(allTokenized);
-        return { records: allRecords, tokenized: allTokenized, idf, norms: allNorms, lastAccessTimestamp: Date.now() };
+        const cached = { records: allRecords, tokenized: allTokenized, idf, norms: allNorms, lastAccessTimestamp: Date.now() };
+        // FUZZY_CHANNEL (1.4.2): reuse the per-scope entry index when the
+        // request is single-scope (the common path); multi-scope requests
+        // build a merged index on each call. Threshold changes rebuild.
+        if (scopes.length === 1 && this.scopeCache.has(scopes[0])) {
+            const entry = this.scopeCache.get(scopes[0]);
+            if (entry?.fuse) {
+                cached.fuse = entry.fuse;
+            }
+        }
+        return cached;
+    }
+    // FUZZY_CHANNEL (1.4.2): lazily build (and cache) the fuse.js index over
+    // the records a search is about to score. Built once per scope-cache
+    // entry and reused across searches; rebuilt when the threshold changes or
+    // the cache entry is invalidated (the entry itself is replaced on
+    // invalidation, so this never serves stale text).
+    getFuzzyIndex(cached, scopes, threshold) {
+        if (cached.fuse && cached.fuse.threshold === threshold) {
+            return cached.fuse;
+        }
+        const fuse = buildFuseIndex(cached.records, threshold);
+        fuse.threshold = threshold;
+        cached.fuse = fuse;
+        if (scopes.length === 1 && this.scopeCache.has(scopes[0])) {
+            this.scopeCache.get(scopes[0]).fuse = fuse;
+        }
+        return fuse;
     }
     enforceMaxScopes() {
         while (this.scopeCache.size > this.cacheConfig.maxScopes) {
@@ -2952,14 +2997,27 @@ function buildRankMap(items, scoreOf) {
     }
     return ranks;
 }
-function normalizeChannelWeights(vectorWeight, bm25Weight) {
-    const sum = vectorWeight + bm25Weight;
+// FUZZY_CHANNEL (1.4.2): fuse.js index over memory text. ignoreLocation
+// keeps substring matches relevant, ignoreDiacritics tolerates accents, and
+// threshold (default 0.5) drops results whose match score is too weak.
+function buildFuseIndex(records, threshold = 0.5) {
+    return new Fuse(records, {
+        keys: ["text"],
+        includeScore: true,
+        ignoreLocation: true,
+        ignoreDiacritics: true,
+        threshold,
+    });
+}
+function normalizeChannelWeights(vectorWeight, bm25Weight, fuzzyWeight = 0) {
+    const sum = vectorWeight + bm25Weight + fuzzyWeight;
     if (sum <= 0) {
-        return { vectorWeight: 0.5, bm25Weight: 0.5 };
+        return { vectorWeight: 0.5, bm25Weight: 0.5, fuzzyWeight: 0 };
     }
     return {
         vectorWeight: vectorWeight / sum,
         bm25Weight: bm25Weight / sum,
+        fuzzyWeight: fuzzyWeight / sum,
     };
 }
 function computeRecencyMultiplier(timestamp, halfLifeHours) {

package/dist/tools/memory.js

@@ -89,6 +89,10 @@ export function createMemoryTools(state) {
                 const isFallback = embedderFailed || queryVector.length === 0;
                 const effectiveVectorWeight = isFallback ? 0 : (state.config.retrieval.mode === "vector" ? 1 : state.config.retrieval.vectorWeight);
                 const effectiveBm25Weight = isFallback ? 1 : (state.config.retrieval.mode === "vector" ? 0 : state.config.retrieval.bm25Weight);
+                // FUZZY_CHANNEL (1.4.2): fuzzy stays on in the bm25-only
+                // fallback (that's when typo tolerance helps most); it is
+                // disabled only in explicit vector-only mode.
+                const effectiveFuzzyWeight = state.config.retrieval.mode === "vector" ? 0 : state.config.retrieval.fuzzyWeight;
                 if (isFallback) {
                     log("info", "Using BM25-only search (embedder unavailable)");
                 }
@@ -99,6 +103,8 @@ export function createMemoryTools(state) {
                     limit: args.limit ?? 5,
                     vectorWeight: effectiveVectorWeight,
                     bm25Weight: effectiveBm25Weight,
+                    fuzzyWeight: effectiveFuzzyWeight,
+                    fuzzyThreshold: state.config.retrieval.fuzzyThreshold,
                     minScore: state.config.retrieval.minScore,
                     rrfK: state.config.retrieval.rrfK,
                     recencyBoost: state.config.retrieval.recencyBoost,
@@ -306,6 +312,11 @@ export function createMemoryTools(state) {
                     recentCount: entries.length,
                     incompatibleVectors,
                     index: health,
+                    fuzzy: {
+                        enabled: (state.config.retrieval.fuzzyWeight ?? 0) > 0,
+                        weight: state.config.retrieval.fuzzyWeight ?? 0,
+                        threshold: state.config.retrieval.fuzzyThreshold ?? 0.5,
+                    },
                     embeddingModel: state.config.embedding.model,
                     searchMode,
                     embedderHealth,
@@ -787,6 +798,7 @@ ${explanations.join("\n")}`;
                         limit: args.limit ?? 20,
                         vectorWeight: 0.7,
                         bm25Weight: 0.3,
+                        fuzzyWeight: 0,
                         minScore: 0.2,
                         globalDiscountFactor: 1.0,
                     }).then((results) => results.map((r) => r.record));

package/dist/types.d.ts

@@ -54,6 +54,8 @@ export interface RetrievalConfig {
     mode: RetrievalMode;
     vectorWeight: number;
     bm25Weight: number;
+    fuzzyWeight: number;
+    fuzzyThreshold: number;
     minScore: number;
     rrfK: number;
     recencyBoost: boolean;
@@ -197,6 +199,7 @@ export interface SearchResult {
     score: number;
     vectorScore: number;
     bm25Score: number;
+    fuzzyScore: number;
 }
 export interface CaptureCandidate {
     text: string;

package/opencode-memory-pro.example.json

@@ -19,6 +19,8 @@
     "mode": "hybrid",
     "vectorWeight": 0.7,
     "bm25Weight": 0.3,
+    "fuzzyWeight": 0.15,
+    "fuzzyThreshold": 0.5,
     "minScore": 0.2,
     "rrfK": 60,
     "recencyBoost": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memory-pro",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "LanceDB-backed long-term memory provider for OpenCode — standalone fork of lancedb-opencode-pro with entity graph, lifecycle, and retention",
   "type": "module",
   "main": "dist/index.js",
@@ -44,7 +44,8 @@
   "dependencies": {
     "@lancedb/lancedb": "^0.38.0",
     "@opencode-ai/plugin": "^1.4.10",
-    "@opencode-ai/sdk": "^1.4.10"
+    "@opencode-ai/sdk": "^1.4.10",
+    "fuse.js": "^7.5.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.9",