fossel 1.1.1 → 1.2.1

package/README.md

@@ -20,7 +20,31 @@
    npx -y fossel
    ```
 
-4. In chat, just say *"remember this"* and Fossel handles the rest. See [Simple mode](#simple-mode-recommended) below.
+4. In chat, say:
+
+   ```
+   remember: [anything about this repo]
+   ```
+
+   Then ask:
+
+   ```
+   what does Fossel remember about [topic]?
+   ```
+
+5. **Verify it works** — paste this in your AI chat:
+
+   ```
+   remember: Fossel is working in this repo
+   ```
+
+   Then immediately ask:
+
+   ```
+   what does Fossel remember?
+   ```
+
+   You should see your memory returned.
 
 **Database path:** `~/.fossel/memory.db` (override with `FOSSEL_DB_PATH`).
 
@@ -76,17 +100,14 @@ Every original tool is still available for power users.
 
 | Tool | Purpose |
 |------|---------|
-| `remember` | Natural-language save with auto-type/tags/dedupe (preferred). |
-| `get_context` | Unified pinned + recent + FTS retrieval. |
-| `resolve_repo` | Show canonical key, aliases, detected git remote. |
-| `dedupe_repo` | Find or merge near-duplicate memories. |
-| `store_context` | Explicit save with `type` and `tags`. |
-| `get_repo_context` | Recent memories grouped by type (pinned first). |
-| `search_memory` | FTS search, optional repo filter. |
-| `summarize_repo_context` | Markdown brief for a repo. |
-| `pin_memory` / `unpin_memory` | Pin important items. |
-| `update_memory` | Partial update by numeric id. |
-| `delete_memory` | Delete by legacy string id. |
+| `remember` | Save a memory in natural language — auto-infers type, tags, and repo |
+| `get_context` | Retrieve relevant memories, pinned first then recent |
+| `search_memory` | FTS search across notes, optional repo filter |
+| `pin_memory` / `unpin_memory` | Pin important memories to always appear first |
+| `delete_memory` | Delete by id |
+| `update_memory` | Edit an existing memory by id |
+| `dedupe_repo` | Merge near-duplicate memories |
+| `summarize_repo_context` | Markdown summary — useful for PR descriptions |
 
 ### Memory types
 
@@ -175,10 +196,6 @@ Reports on:
 
 Pass `--fix` to apply safe automated cleanup in one go: merge sibling repo keys, rewrite stale alias mentions, and remove exact-text duplicates. Without `--fix` it's read-only and exits non-zero on issues so it can run in CI.
 
-### `fossel init`
-
-`fossel init` auto-deduplicates exact duplicate memories at the end of the run; pass `--no-dedupe` to opt out.
-
 ---
 
 ## Cursor MCP config
@@ -208,7 +225,7 @@ Pass `--fix` to apply safe automated cleanup in one go: merge sibling repo keys,
       "command": "npx",
       "args": ["-y", "fossel"],
       "env": {
-        "FOSSEL_WORKSPACE": "/absolute/path/to/your/project"
+        "FOSSEL_WORKSPACE": "/path/to/your/project"
       }
     }
   }
@@ -235,10 +252,54 @@ npm run ci           # typecheck + tests + build + smoke
 ## Notes
 
 - **Local-first:** data stays on your machine.
-- **Search:** FTS5 (no `sqlite-vec` in v1).
+- **Search:** FTS5 keyword search by default. Optional **hybrid semantic search**
+  via `FOSSEL_EMBEDDINGS=1` (see below).
 - **`FOSSEL_DB_PATH`:** optional override for DB location (e.g. tests).
 - **Schema:** migrations live in `src/db/migrate.ts`; reference shape in `src/db/schema.sql`.
 
+## Hybrid semantic search (optional)
+
+By default Fossel retrieves memories with FTS5 keyword search. Keyword search
+misses paraphrases — a query like "how does authentication work?" won't match a
+note that says "JWT lives in localStorage" because they share no words.
+
+Set `FOSSEL_EMBEDDINGS=1` to enable **hybrid retrieval**: a local, dependency-free
+embedding is computed for every memory and fused with the keyword results
+(Reciprocal Rank Fusion). This adds semantic recall while keeping FTS5's exact-
+match precision for identifiers, file paths, and ticket numbers.
+
+```json
+{
+  "mcpServers": {
+    "fossel": {
+      "command": "npx",
+      "args": ["-y", "fossel"],
+      "env": {
+        "FOSSEL_WORKSPACE": "${workspaceFolder}",
+        "FOSSEL_EMBEDDINGS": "1"
+      }
+    }
+  }
+}
+```
+
+Properties:
+
+- **Zero install weight / fully offline.** The embedding is a deterministic
+  feature-hashing of token unigrams and bigrams — no model download, no native
+  dependency, no network. It runs instantly and keeps the local-first promise.
+- **Opt-in.** With the flag unset, Fossel behaves exactly as before: no vectors
+  are written and retrieval is FTS-only.
+- **Self-healing index.** Memories created before enabling the flag are embedded
+  on demand the first time the repo is searched.
+- **Pluggable.** `embedText` in `src/lib/embeddings.ts` is the single entry
+  point, so a stronger embedder (transformers.js, ONNX, or a remote model) can
+  be swapped in later without touching callers. Bump `EMBEDDING_VERSION` to
+  trigger automatic re-indexing of stale vectors.
+
+Vectors are stored in a `memory_embeddings` side table keyed by memory rowid and
+cleaned up via trigger when a memory is deleted.
+
 ## Community
 
 If Fossel saves you time, **[star the repo](https://github.com/7vignesh/fossel)** and **[open an issue](https://github.com/7vignesh/fossel/issues)** for bugs or ideas — that helps others discover it too.

package/dist/cli.js

@@ -164,6 +164,25 @@ var init_migrate = __esm({
             tx(rows);
           }
         }
+      },
+      {
+        name: "007_add_memory_embeddings",
+        apply: (db) => {
+          db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_embeddings (
+          memory_rowid INTEGER PRIMARY KEY,
+          dim INTEGER NOT NULL,
+          version INTEGER NOT NULL,
+          vector BLOB NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memories_embeddings_ad
+        AFTER DELETE ON memories BEGIN
+          DELETE FROM memory_embeddings WHERE memory_rowid = old.rowid;
+        END;
+      `);
+        }
       }
     ];
   }
@@ -538,6 +557,170 @@ var init_repo = __esm({
   }
 });
 
+// src/lib/embeddings.ts
+function embeddingsEnabled() {
+  const value = process.env.FOSSEL_EMBEDDINGS?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "on" || value === "yes";
+}
+function fnv1a(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i += 1) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function tokenize2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim().split(" ").filter((token) => token.length >= 2);
+}
+function embedText(text) {
+  const vector = new Float32Array(EMBEDDING_DIM);
+  const tokens = tokenize2(text);
+  if (tokens.length === 0) {
+    return vector;
+  }
+  const addFeature = (feature, weight) => {
+    const h = fnv1a(feature);
+    const index = h % EMBEDDING_DIM;
+    const sign = (fnv1a(`#${feature}`) & 1) === 0 ? 1 : -1;
+    vector[index] += sign * weight;
+  };
+  for (let i = 0; i < tokens.length; i += 1) {
+    addFeature(tokens[i], 1);
+    if (i + 1 < tokens.length) {
+      addFeature(`${tokens[i]} ${tokens[i + 1]}`, 0.6);
+    }
+  }
+  let norm = 0;
+  for (let i = 0; i < EMBEDDING_DIM; i += 1) {
+    norm += vector[i] * vector[i];
+  }
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < EMBEDDING_DIM; i += 1) {
+      vector[i] /= norm;
+    }
+  }
+  return vector;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    return 0;
+  }
+  let dot = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function vectorToBuffer(vector) {
+  return Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
+}
+function bufferToVector(buffer) {
+  const copy = Buffer.from(buffer);
+  return new Float32Array(
+    copy.buffer,
+    copy.byteOffset,
+    Math.floor(copy.byteLength / 4)
+  );
+}
+var EMBEDDING_DIM, EMBEDDING_VERSION;
+var init_embeddings = __esm({
+  "src/lib/embeddings.ts"() {
+    "use strict";
+    EMBEDDING_DIM = 256;
+    EMBEDDING_VERSION = 1;
+  }
+});
+
+// src/lib/vector-index.ts
+function indexMemoryEmbedding(db, rowId, note) {
+  if (!embeddingsEnabled()) {
+    return;
+  }
+  const vector = embedText(note);
+  db.prepare(
+    `
+      INSERT INTO memory_embeddings (memory_rowid, dim, version, vector, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(memory_rowid) DO UPDATE SET
+        dim = excluded.dim,
+        version = excluded.version,
+        vector = excluded.vector,
+        updated_at = excluded.updated_at
+    `
+  ).run(
+    rowId,
+    EMBEDDING_DIM,
+    EMBEDDING_VERSION,
+    vectorToBuffer(vector),
+    Math.floor(Date.now() / 1e3)
+  );
+}
+function backfillRepoEmbeddings(db, repo) {
+  if (!embeddingsEnabled()) {
+    return 0;
+  }
+  const rows = db.prepare(
+    `
+        SELECT m.rowid AS row_id, m.note
+        FROM memories AS m
+        LEFT JOIN memory_embeddings AS e ON e.memory_rowid = m.rowid
+        WHERE m.repo = ?
+          AND (e.memory_rowid IS NULL OR e.version != ? OR e.dim != ?)
+      `
+  ).all(repo, EMBEDDING_VERSION, EMBEDDING_DIM);
+  if (rows.length === 0) {
+    return 0;
+  }
+  const tx = db.transaction((batch) => {
+    for (const row of batch) {
+      indexMemoryEmbedding(db, row.row_id, row.note);
+    }
+  });
+  tx(rows);
+  return rows.length;
+}
+function vectorSearch(db, repo, query, limit) {
+  if (!embeddingsEnabled()) {
+    return [];
+  }
+  backfillRepoEmbeddings(db, repo);
+  const queryVector = embedText(query);
+  let queryNorm = 0;
+  for (let i = 0; i < queryVector.length; i += 1) {
+    queryNorm += queryVector[i] * queryVector[i];
+  }
+  if (queryNorm === 0) {
+    return [];
+  }
+  const rows = db.prepare(
+    `
+        SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags,
+               m.created_at, m.updated_at, m.pinned, e.vector AS vector
+        FROM memory_embeddings AS e
+        JOIN memories AS m ON m.rowid = e.memory_rowid
+        WHERE m.repo = ? AND e.dim = ? AND e.version = ?
+      `
+  ).all(repo, EMBEDDING_DIM, EMBEDDING_VERSION);
+  const scored = [];
+  for (const row of rows) {
+    const { vector, ...memory } = row;
+    const score = cosineSimilarity(queryVector, bufferToVector(vector));
+    if (score > 0) {
+      scored.push({ ...memory, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+var init_vector_index = __esm({
+  "src/lib/vector-index.ts"() {
+    "use strict";
+    init_embeddings();
+  }
+});
+
 // src/lib/context.ts
 function parseTags(raw) {
   try {
@@ -587,7 +770,10 @@ function fetchRepoContext(db, repo, limit, query) {
   for (const row of pinned) {
     push(row, "pinned");
   }
-  if (rows.length < limit) {
+  const pushRecent = () => {
+    if (rows.length >= limit) {
+      return;
+    }
     const recent = db.prepare(
       `
           SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
@@ -596,13 +782,20 @@ function fetchRepoContext(db, repo, limit, query) {
           ORDER BY updated_at DESC
           LIMIT ?
         `
-    ).all(repo, limit - rows.length);
+    ).all(repo, limit);
     for (const row of recent) {
       push(row, "recent");
+      if (rows.length >= limit) {
+        break;
+      }
     }
+  };
+  if (!query) {
+    pushRecent();
   }
   if (query && rows.length < limit) {
     const ftsQuery = buildFtsQuery(query);
+    const ftsRows = [];
     if (ftsQuery) {
       try {
         const matches = db.prepare(
@@ -616,15 +809,49 @@ function fetchRepoContext(db, repo, limit, query) {
               LIMIT ?
             `
         ).all(ftsQuery, repo, limit);
-        for (const row of matches) {
-          push(row, "search", row.rank);
-          if (rows.length >= limit) {
-            break;
+        ftsRows.push(...matches);
+      } catch {
+      }
+    }
+    const vectorRows = embeddingsEnabled() ? vectorSearch(db, repo, query, limit) : [];
+    if (vectorRows.length > 0) {
+      const RRF_K = 60;
+      const fused = /* @__PURE__ */ new Map();
+      const accumulate = (list, rankOf) => {
+        list.forEach((memory, index) => {
+          const contribution = 1 / (RRF_K + index + 1);
+          const prior = fused.get(memory.row_id);
+          if (prior) {
+            prior.score += contribution;
+          } else {
+            fused.set(memory.row_id, {
+              memory,
+              score: contribution,
+              rank: rankOf?.(memory, index)
+            });
           }
+        });
+      };
+      accumulate(ftsRows, (m) => m.rank);
+      accumulate(vectorRows);
+      const ordered = Array.from(fused.values()).sort(
+        (a, b) => b.score - a.score
+      );
+      for (const { memory, rank } of ordered) {
+        push(memory, "search", rank);
+        if (rows.length >= limit) {
+          break;
+        }
+      }
+    } else {
+      for (const row of ftsRows) {
+        push(row, "search", row.rank);
+        if (rows.length >= limit) {
+          break;
         }
-      } catch {
       }
     }
+    pushRecent();
   }
   return rows.slice(0, limit);
 }
@@ -687,6 +914,8 @@ var init_context = __esm({
   "src/lib/context.ts"() {
     "use strict";
     init_client();
+    init_embeddings();
+    init_vector_index();
     SECTION_TITLES = {
       convention: "Conventions",
       bug_fix: "Bug Fixes",
@@ -1725,6 +1954,7 @@ function registerRememberTool(server) {
             now,
             existing.row_id
           );
+          indexMemoryEmbedding(db, existing.row_id, longerNote);
           return {
             content: [
               {
@@ -1765,6 +1995,9 @@ function registerRememberTool(server) {
           normalizeText(note)
         );
         const inserted = db.prepare("SELECT rowid AS row_id FROM memories WHERE id = ?").get(id);
+        if (inserted) {
+          indexMemoryEmbedding(db, inserted.row_id, note);
+        }
         return {
           content: [
             {
@@ -1796,6 +2029,7 @@ var init_remember = __esm({
     init_dedupe();
     init_inference();
     init_repo();
+    init_vector_index();
     init_workspace();
     rememberInputSchema = {
       note: z6.string().trim().min(1, "note is required"),
@@ -1942,6 +2176,13 @@ function registerSearchMemoryTool(server) {
             rows = runFts(orQuery, resolvedRepo, limit);
           }
         }
+        if (rows.length === 0 && resolvedRepo && embeddingsEnabled()) {
+          const semantic = vectorSearch(db, resolvedRepo, query, limit);
+          rows = semantic.map(({ score, ...row }) => ({
+            ...row,
+            rank: score
+          }));
+        }
         let usedFallback = false;
         if (rows.length === 0 && resolvedRepo) {
           const fallback = fetchRepoContext(db, resolvedRepo, limit);
@@ -1997,7 +2238,9 @@ var init_search = __esm({
     "use strict";
     init_client();
     init_context();
+    init_embeddings();
     init_repo();
+    init_vector_index();
     init_workspace();
     searchMemoryInputSchema = {
       query: z8.string().trim().min(1, "query is required"),
@@ -2048,6 +2291,9 @@ function registerStoreContextTool(server) {
               WHERE id = ?
             `
         ).get(id);
+        if (stored) {
+          indexMemoryEmbedding(db, stored.row_id, note);
+        }
         return {
           content: [
             {
@@ -2078,6 +2324,7 @@ var init_store = __esm({
     init_client();
     init_dedupe();
     init_repo();
+    init_vector_index();
     init_workspace();
     storeContextInputSchema = {
       repo: z9.string().trim().min(1).optional(),
@@ -2257,6 +2504,7 @@ function registerUpdateMemoryTool(server) {
               WHERE rowid = ?
             `
           ).run(nextType, nextNote, nextNormalized, now, existing.row_id);
+          indexMemoryEmbedding(db, existing.row_id, nextNote);
         } else {
           db.prepare(
             `
@@ -2314,6 +2562,7 @@ var init_update = __esm({
     init_client();
     init_dedupe();
     init_memory();
+    init_vector_index();
     updateMemoryInputSchema = {
       // Accept numeric row_id or legacy string id so callers can paste whichever
       // form they have.
@@ -2387,7 +2636,7 @@ async function startServer() {
   initDb(dbPath);
   const server = new McpServer({
     name: "fossel",
-    version: "1.1.1"
+    version: "1.2.1"
   });
   registerRememberTool(server);
   registerGetContextTool(server);

package/dist/index.js

@@ -138,6 +138,25 @@ var migrations = [
         tx(rows);
       }
     }
+  },
+  {
+    name: "007_add_memory_embeddings",
+    apply: (db) => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_embeddings (
+          memory_rowid INTEGER PRIMARY KEY,
+          dim INTEGER NOT NULL,
+          version INTEGER NOT NULL,
+          vector BLOB NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memories_embeddings_ad
+        AFTER DELETE ON memories BEGIN
+          DELETE FROM memory_embeddings WHERE memory_rowid = old.rowid;
+        END;
+      `);
+    }
   }
 ];
 function runMigrations(db) {
@@ -195,6 +214,158 @@ function getDb() {
   return dbInstance;
 }
 
+// src/lib/embeddings.ts
+var EMBEDDING_DIM = 256;
+var EMBEDDING_VERSION = 1;
+function embeddingsEnabled() {
+  const value = process.env.FOSSEL_EMBEDDINGS?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "on" || value === "yes";
+}
+function fnv1a(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i += 1) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim().split(" ").filter((token) => token.length >= 2);
+}
+function embedText(text) {
+  const vector = new Float32Array(EMBEDDING_DIM);
+  const tokens = tokenize(text);
+  if (tokens.length === 0) {
+    return vector;
+  }
+  const addFeature = (feature, weight) => {
+    const h = fnv1a(feature);
+    const index = h % EMBEDDING_DIM;
+    const sign = (fnv1a(`#${feature}`) & 1) === 0 ? 1 : -1;
+    vector[index] += sign * weight;
+  };
+  for (let i = 0; i < tokens.length; i += 1) {
+    addFeature(tokens[i], 1);
+    if (i + 1 < tokens.length) {
+      addFeature(`${tokens[i]} ${tokens[i + 1]}`, 0.6);
+    }
+  }
+  let norm = 0;
+  for (let i = 0; i < EMBEDDING_DIM; i += 1) {
+    norm += vector[i] * vector[i];
+  }
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < EMBEDDING_DIM; i += 1) {
+      vector[i] /= norm;
+    }
+  }
+  return vector;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    return 0;
+  }
+  let dot = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function vectorToBuffer(vector) {
+  return Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
+}
+function bufferToVector(buffer) {
+  const copy = Buffer.from(buffer);
+  return new Float32Array(
+    copy.buffer,
+    copy.byteOffset,
+    Math.floor(copy.byteLength / 4)
+  );
+}
+
+// src/lib/vector-index.ts
+function indexMemoryEmbedding(db, rowId, note) {
+  if (!embeddingsEnabled()) {
+    return;
+  }
+  const vector = embedText(note);
+  db.prepare(
+    `
+      INSERT INTO memory_embeddings (memory_rowid, dim, version, vector, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(memory_rowid) DO UPDATE SET
+        dim = excluded.dim,
+        version = excluded.version,
+        vector = excluded.vector,
+        updated_at = excluded.updated_at
+    `
+  ).run(
+    rowId,
+    EMBEDDING_DIM,
+    EMBEDDING_VERSION,
+    vectorToBuffer(vector),
+    Math.floor(Date.now() / 1e3)
+  );
+}
+function backfillRepoEmbeddings(db, repo) {
+  if (!embeddingsEnabled()) {
+    return 0;
+  }
+  const rows = db.prepare(
+    `
+        SELECT m.rowid AS row_id, m.note
+        FROM memories AS m
+        LEFT JOIN memory_embeddings AS e ON e.memory_rowid = m.rowid
+        WHERE m.repo = ?
+          AND (e.memory_rowid IS NULL OR e.version != ? OR e.dim != ?)
+      `
+  ).all(repo, EMBEDDING_VERSION, EMBEDDING_DIM);
+  if (rows.length === 0) {
+    return 0;
+  }
+  const tx = db.transaction((batch) => {
+    for (const row of batch) {
+      indexMemoryEmbedding(db, row.row_id, row.note);
+    }
+  });
+  tx(rows);
+  return rows.length;
+}
+function vectorSearch(db, repo, query, limit) {
+  if (!embeddingsEnabled()) {
+    return [];
+  }
+  backfillRepoEmbeddings(db, repo);
+  const queryVector = embedText(query);
+  let queryNorm = 0;
+  for (let i = 0; i < queryVector.length; i += 1) {
+    queryNorm += queryVector[i] * queryVector[i];
+  }
+  if (queryNorm === 0) {
+    return [];
+  }
+  const rows = db.prepare(
+    `
+        SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags,
+               m.created_at, m.updated_at, m.pinned, e.vector AS vector
+        FROM memory_embeddings AS e
+        JOIN memories AS m ON m.rowid = e.memory_rowid
+        WHERE m.repo = ? AND e.dim = ? AND e.version = ?
+      `
+  ).all(repo, EMBEDDING_DIM, EMBEDDING_VERSION);
+  const scored = [];
+  for (const row of rows) {
+    const { vector, ...memory } = row;
+    const score = cosineSimilarity(queryVector, bufferToVector(vector));
+    if (score > 0) {
+      scored.push({ ...memory, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+
 // src/lib/context.ts
 var SECTION_TITLES = {
   convention: "Conventions",
@@ -252,7 +423,10 @@ function fetchRepoContext(db, repo, limit, query) {
   for (const row of pinned) {
     push(row, "pinned");
   }
-  if (rows.length < limit) {
+  const pushRecent = () => {
+    if (rows.length >= limit) {
+      return;
+    }
     const recent = db.prepare(
       `
           SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
@@ -261,13 +435,20 @@ function fetchRepoContext(db, repo, limit, query) {
           ORDER BY updated_at DESC
           LIMIT ?
         `
-    ).all(repo, limit - rows.length);
+    ).all(repo, limit);
     for (const row of recent) {
       push(row, "recent");
+      if (rows.length >= limit) {
+        break;
+      }
     }
+  };
+  if (!query) {
+    pushRecent();
   }
   if (query && rows.length < limit) {
     const ftsQuery = buildFtsQuery(query);
+    const ftsRows = [];
     if (ftsQuery) {
       try {
         const matches = db.prepare(
@@ -281,15 +462,49 @@ function fetchRepoContext(db, repo, limit, query) {
               LIMIT ?
             `
         ).all(ftsQuery, repo, limit);
-        for (const row of matches) {
-          push(row, "search", row.rank);
-          if (rows.length >= limit) {
-            break;
+        ftsRows.push(...matches);
+      } catch {
+      }
+    }
+    const vectorRows = embeddingsEnabled() ? vectorSearch(db, repo, query, limit) : [];
+    if (vectorRows.length > 0) {
+      const RRF_K = 60;
+      const fused = /* @__PURE__ */ new Map();
+      const accumulate = (list, rankOf) => {
+        list.forEach((memory, index) => {
+          const contribution = 1 / (RRF_K + index + 1);
+          const prior = fused.get(memory.row_id);
+          if (prior) {
+            prior.score += contribution;
+          } else {
+            fused.set(memory.row_id, {
+              memory,
+              score: contribution,
+              rank: rankOf?.(memory, index)
+            });
           }
+        });
+      };
+      accumulate(ftsRows, (m) => m.rank);
+      accumulate(vectorRows);
+      const ordered = Array.from(fused.values()).sort(
+        (a, b) => b.score - a.score
+      );
+      for (const { memory, rank } of ordered) {
+        push(memory, "search", rank);
+        if (rows.length >= limit) {
+          break;
+        }
+      }
+    } else {
+      for (const row of ftsRows) {
+        push(row, "search", row.rank);
+        if (rows.length >= limit) {
+          break;
         }
-      } catch {
       }
     }
+    pushRecent();
   }
   return rows.slice(0, limit);
 }
@@ -501,7 +716,7 @@ var DEFAULT_CANDIDATE_LIMIT = 200;
 function normalizeText(text) {
   return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
-function tokenize(text) {
+function tokenize2(text) {
   return normalizeText(text).split(" ").filter((token) => token.length >= 2);
 }
 function trigrams(text) {
@@ -537,7 +752,7 @@ function similarity(a, b) {
   if (normalizedA === normalizedB) {
     return 1;
   }
-  const wordScore = jaccard(new Set(tokenize(normalizedA)), new Set(tokenize(normalizedB)));
+  const wordScore = jaccard(new Set(tokenize2(normalizedA)), new Set(tokenize2(normalizedB)));
   const triScore = jaccard(trigrams(normalizedA), trigrams(normalizedB));
   return wordScore * 0.55 + triScore * 0.45;
 }
@@ -1545,6 +1760,7 @@ function registerRememberTool(server) {
             now,
             existing.row_id
           );
+          indexMemoryEmbedding(db, existing.row_id, longerNote);
           return {
             content: [
               {
@@ -1585,6 +1801,9 @@ function registerRememberTool(server) {
           normalizeText(note)
         );
         const inserted = db.prepare("SELECT rowid AS row_id FROM memories WHERE id = ?").get(id);
+        if (inserted) {
+          indexMemoryEmbedding(db, inserted.row_id, note);
+        }
         return {
           content: [
             {
@@ -1741,6 +1960,13 @@ function registerSearchMemoryTool(server) {
             rows = runFts(orQuery, resolvedRepo, limit);
           }
         }
+        if (rows.length === 0 && resolvedRepo && embeddingsEnabled()) {
+          const semantic = vectorSearch(db, resolvedRepo, query, limit);
+          rows = semantic.map(({ score, ...row }) => ({
+            ...row,
+            rank: score
+          }));
+        }
         let usedFallback = false;
         if (rows.length === 0 && resolvedRepo) {
           const fallback = fetchRepoContext(db, resolvedRepo, limit);
@@ -1838,6 +2064,9 @@ function registerStoreContextTool(server) {
               WHERE id = ?
             `
         ).get(id);
+        if (stored) {
+          indexMemoryEmbedding(db, stored.row_id, note);
+        }
         return {
           content: [
             {
@@ -2029,6 +2258,7 @@ function registerUpdateMemoryTool(server) {
               WHERE rowid = ?
             `
           ).run(nextType, nextNote, nextNormalized, now, existing.row_id);
+          indexMemoryEmbedding(db, existing.row_id, nextNote);
         } else {
           db.prepare(
             `
@@ -2133,7 +2363,7 @@ async function startServer() {
   initDb(dbPath);
   const server = new McpServer({
     name: "fossel",
-    version: "1.1.1"
+    version: "1.2.1"
   });
   registerRememberTool(server);
   registerGetContextTool(server);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fossel",
-  "version": "1.1.1",
-  "description": "Local-first MCP memory for Cursor & Claude: repo context in SQLite, FTS5 search, pins, PR summaries. No cloud.",
+  "version": "1.2.1",
+  "description": "Local-first MCP memory for Cursor & Claude: repo context in SQLite with hybrid keyword + semantic search, pins, PR summaries. No cloud.",
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -11,6 +11,8 @@
     "memory",
     "sqlite",
     "fts5",
+    "semantic-search",
+    "embeddings",
     "open-source",
     "contributors",
     "local-first",