context-mode 1.0.78 → 1.0.80

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.78"
+    "version": "1.0.80"
   },
   "plugins": [
     {
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "1.0.78",
+      "version": "1.0.80",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.78",
+  "version": "1.0.80",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/.openclaw-plugin/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.78",
+  "version": "1.0.80",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.78",
+  "version": "1.0.80",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
   "author": {
     "name": "Mert Koseoğlu",

package/build/db-base.js

@@ -222,6 +222,15 @@ export function loadDatabase() {
 export function applyWALPragmas(db) {
     db.pragma("journal_mode = WAL");
     db.pragma("synchronous = NORMAL");
+    // Memory-map the DB file for read-heavy FTS5 search workloads.
+    // Eliminates read() syscalls — the kernel serves pages directly from
+    // the page cache. 256MB is a safe upper bound (SQLite only maps up to
+    // the actual file size). Falls back gracefully on platforms where mmap
+    // is unavailable or restricted.
+    try {
+        db.pragma("mmap_size = 268435456");
+    }
+    catch { /* unsupported runtime */ }
 }
 // ─────────────────────────────────────────────────────────
 // DB file helpers

package/build/store.d.ts

@@ -23,6 +23,7 @@ export declare function cleanupStaleDBs(): number;
 export declare function cleanupStaleContentDBs(contentDir: string, maxAgeDays: number): number;
 export declare class ContentStore {
     #private;
+    static readonly OPTIMIZE_EVERY = 50;
     constructor(dbPath?: string);
     /** Delete this session's DB files. Call on process exit. */
     cleanup(): void;

package/build/store.js

@@ -7,6 +7,7 @@
  * Use for documentation, API references, and any content where
  * you need EXACT text later — not summaries.
  */
+var _a;
 import { loadDatabase, applyWALPragmas, closeDB, cleanOrphanedWALFiles, withRetry, deleteDBFiles, isSQLiteCorruptionError } from "./db-base.js";
 import { readFileSync, readdirSync, unlinkSync, existsSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -40,7 +41,12 @@ function sanitizeQuery(query, mode = "AND") {
         !["AND", "OR", "NOT", "NEAR"].includes(w.toUpperCase()));
     if (words.length === 0)
         return '""';
-    return words.map((w) => `"${w}"`).join(mode === "OR" ? " OR " : " ");
+    // Filter stopwords to improve BM25 ranking — common terms like "update",
+    // "test", "fix" appear everywhere and dilute relevance scoring.
+    // Fall back to unfiltered words if ALL terms are stopwords.
+    const meaningful = words.filter((w) => !STOPWORDS.has(w.toLowerCase()));
+    const final = meaningful.length > 0 ? meaningful : words;
+    return final.map((w) => `"${w}"`).join(mode === "OR" ? " OR " : " ");
 }
 function sanitizeTrigramQuery(query, mode = "AND") {
     const cleaned = query.replace(/["'(){}[\]*:^~]/g, "").trim();
@@ -49,7 +55,9 @@ function sanitizeTrigramQuery(query, mode = "AND") {
     const words = cleaned.split(/\s+/).filter((w) => w.length >= 3);
     if (words.length === 0)
         return "";
-    return words.map((w) => `"${w}"`).join(mode === "OR" ? " OR " : " ");
+    const meaningful = words.filter((w) => !STOPWORDS.has(w.toLowerCase()));
+    const final = meaningful.length > 0 ? meaningful : words;
+    return final.map((w) => `"${w}"`).join(mode === "OR" ? " OR " : " ");
 }
 function levenshtein(a, b) {
     if (a.length === 0)
@@ -263,6 +271,15 @@ export class ContentStore {
     #stmtChunkContent;
     #stmtStats;
     #stmtSourceMeta;
+    // Cleanup path
+    #stmtCleanupChunks;
+    #stmtCleanupChunksTrigram;
+    #stmtCleanupSources;
+    // FTS5 optimization: track inserts and optimize periodically to defragment
+    // the index. FTS5 b-trees fragment over many insert/delete cycles, degrading
+    // search performance. SQLite's built-in 'optimize' merges b-tree segments.
+    #insertCount = 0;
+    static OPTIMIZE_EVERY = 50;
     constructor(dbPath) {
         const Database = loadDatabase();
         this.#dbPath =
@@ -541,6 +558,10 @@ export class ContentStore {
         (SELECT COUNT(*) FROM chunks) AS chunks,
         (SELECT COUNT(*) FROM chunks WHERE content_type = 'code') AS codeChunks
     `);
+        // Cleanup path — cached to avoid recompiling SQL on each periodic call
+        this.#stmtCleanupChunks = this.#db.prepare("DELETE FROM chunks WHERE source_id IN (SELECT id FROM sources WHERE datetime(indexed_at) < datetime('now', '-' || ? || ' days'))");
+        this.#stmtCleanupChunksTrigram = this.#db.prepare("DELETE FROM chunks_trigram WHERE source_id IN (SELECT id FROM sources WHERE datetime(indexed_at) < datetime('now', '-' || ? || ' days'))");
+        this.#stmtCleanupSources = this.#db.prepare("DELETE FROM sources WHERE datetime(indexed_at) < datetime('now', '-' || ? || ' days')");
     }
     // ── Index ──
     index(options) {
@@ -623,6 +644,14 @@ export class ContentStore {
         const sourceId = transaction();
         if (text)
             this.#extractAndStoreVocabulary(text);
+        // Periodically optimize FTS5 indexes to merge b-tree segments.
+        // Fragmentation accumulates over insert/delete cycles (dedup re-indexes
+        // every source on update). The 'optimize' command merges segments into
+        // a single b-tree, improving search latency for long-running sessions.
+        this.#insertCount++;
+        if (this.#insertCount % _a.OPTIMIZE_EVERY === 0) {
+            this.#optimizeFTS();
+        }
         return {
             sourceId,
             label,
@@ -754,24 +783,35 @@ export class ContentStore {
     }
     // ── Proximity Reranking ──
     #applyProximityReranking(results, query) {
-        const terms = query
+        const allTerms = query
             .toLowerCase()
             .split(/\s+/)
             .filter((w) => w.length >= 2);
-        // Single-term queries: no reranking needed
-        if (terms.length < 2)
-            return results;
+        // Exclude stopwords from proximity/title scoring — they match everywhere
+        // and inflate boosts for irrelevant chunks. Keep all terms as fallback.
+        const filtered = allTerms.filter((w) => !STOPWORDS.has(w));
+        const terms = filtered.length > 0 ? filtered : allTerms;
         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 };
+            // Title-match boost: query terms found in the chunk title get a boost.
+            // Code chunks get a stronger title boost (function/class names are high
+            // signal) while prose chunks get a moderate one (headings are useful but
+            // body carries more weight).
+            const titleLower = r.title.toLowerCase();
+            const titleHits = terms.filter((t) => titleLower.includes(t)).length;
+            const titleWeight = r.contentType === "code" ? 0.6 : 0.3;
+            const titleBoost = titleHits > 0 ? titleWeight * (titleHits / terms.length) : 0;
+            // Proximity boost for multi-term queries
+            let proximityBoost = 0;
+            if (terms.length >= 2) {
+                const content = r.content.toLowerCase();
+                const positions = terms.map((t) => findAllPositions(content, t));
+                if (!positions.some((p) => p.length === 0)) {
+                    const minSpan = findMinSpan(positions);
+                    proximityBoost = 1 / (1 + minSpan / Math.max(content.length, 1));
+                }
             }
-            const minSpan = findMinSpan(positions);
-            const boost = 1 / (1 + minSpan / Math.max(content.length, 1));
-            return { result: r, boost };
+            return { result: r, boost: titleBoost + proximityBoost };
         })
             .sort((a, b) => b.boost - a.boost || a.result.rank - b.result.rank)
             .map(({ result }) => result);
@@ -785,11 +825,13 @@ export class ContentStore {
             return reranked.map((r) => ({ ...r, matchLayer: "rrf" }));
         }
         // Step 2: Fuzzy correction → RRF re-run
+        // Skip stopwords — they'll be filtered by sanitizeQuery anyway, and each
+        // fuzzyCorrect call hits the vocab DB + runs levenshtein comparisons.
         const words = query
             .toLowerCase()
             .trim()
             .split(/\s+/)
-            .filter((w) => w.length >= 3);
+            .filter((w) => w.length >= 3 && !STOPWORDS.has(w));
         const original = words.join(" ");
         const correctedWords = words.map((w) => this.fuzzyCorrect(w) ?? w);
         const correctedQuery = correctedWords.join(" ");
@@ -877,13 +919,10 @@ export class ContentStore {
      * Returns count of deleted sources.
      */
     cleanupStaleSources(maxAgeDays) {
-        const deleteChunks = this.#db.prepare("DELETE FROM chunks WHERE source_id IN (SELECT id FROM sources WHERE datetime(indexed_at) < datetime('now', '-' || ? || ' days'))");
-        const deleteChunksTrigram = this.#db.prepare("DELETE FROM chunks_trigram WHERE source_id IN (SELECT id FROM sources WHERE datetime(indexed_at) < datetime('now', '-' || ? || ' days'))");
-        const deleteSources = this.#db.prepare("DELETE FROM sources WHERE datetime(indexed_at) < datetime('now', '-' || ? || ' days')");
         const cleanup = this.#db.transaction((days) => {
-            deleteChunks.run(days);
-            deleteChunksTrigram.run(days);
-            return deleteSources.run(days);
+            this.#stmtCleanupChunks.run(days);
+            this.#stmtCleanupChunksTrigram.run(days);
+            return this.#stmtCleanupSources.run(days);
         });
         const info = cleanup(maxAgeDays);
         return info.changes;
@@ -897,7 +936,16 @@ export class ContentStore {
             return 0;
         }
     }
+    /** Merge FTS5 b-tree segments for both porter and trigram indexes. */
+    #optimizeFTS() {
+        try {
+            this.#db.exec("INSERT INTO chunks(chunks) VALUES('optimize')");
+            this.#db.exec("INSERT INTO chunks_trigram(chunks_trigram) VALUES('optimize')");
+        }
+        catch { /* best effort — don't block indexing */ }
+    }
     close() {
+        this.#optimizeFTS(); // defragment before close
         closeDB(this.#db); // WAL checkpoint before close — important for persistent DBs
     }
     // ── Vocabulary Extraction ──
@@ -1163,3 +1211,4 @@ export class ContentStore {
         return headingStack.map((h) => h.text).join(" > ");
     }
 }
+_a = ContentStore;