context-mode 1.0.28 → 1.0.30

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.28"
+    "version": "1.0.30"
   },
   "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.28",
+      "version": "1.0.30",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "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.28",
+  "version": "1.0.30",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "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/server.js

@@ -3,13 +3,13 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
-import { existsSync, unlinkSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, unlinkSync, readdirSync, readFileSync, rmSync, mkdirSync } from "node:fs";
 import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir, tmpdir } from "node:os";
 import { z } from "zod";
 import { PolyglotExecutor } from "./executor.js";
-import { ContentStore, cleanupStaleDBs } from "./store.js";
+import { ContentStore, cleanupStaleDBs, cleanupStaleContentDBs } from "./store.js";
 import { readBashPolicies, evaluateCommandDenyOnly, extractShellCommands, readToolDenyPatterns, evaluateFilePath, } from "./security.js";
 import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime, } from "./runtime.js";
 import { classifyNonZeroExit } from "./exit-classify.js";
@@ -73,9 +73,74 @@ function maybeIndexSessionEvents(store) {
     }
     catch { /* best-effort — session continuity never blocks tools */ }
 }
+/**
+ * Compute a per-project persistent path for the ContentStore.
+ * Uses SHA256 of the project dir (normalized for Windows) to avoid collisions.
+ */
+function getStorePath() {
+    const projectDir = process.env.CLAUDE_PROJECT_DIR
+        || process.env.GEMINI_PROJECT_DIR
+        || process.env.OPENCLAW_PROJECT_DIR
+        || process.cwd();
+    const normalized = projectDir.replace(/\\/g, "/");
+    const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+    const dir = join(homedir(), ".context-mode", "content");
+    mkdirSync(dir, { recursive: true });
+    return join(dir, `${hash}.db`);
+}
+/**
+ * Detect fresh vs --continue session.
+ * SessionStart hook writes {hash}.cleanup on "startup", deletes it on "resume".
+ * Flag exists → fresh start → delete old store. Flag missing → continue → keep store.
+ * Uses same hash as getStorePath() so they stay in sync.
+ */
+function isFreshStart() {
+    try {
+        const projectDir = process.env.CLAUDE_PROJECT_DIR
+            || process.env.GEMINI_PROJECT_DIR
+            || process.env.OPENCLAW_PROJECT_DIR
+            || process.cwd();
+        const normalized = projectDir.replace(/\\/g, "/");
+        const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+        // Check all platform config dirs for cleanup flag
+        const configDirs = [".claude", ".gemini", ".cursor", ".kiro", ".config/opencode", ".openclaw"];
+        for (const configDir of configDirs) {
+            const sessionsDir = join(homedir(), configDir, "context-mode", "sessions");
+            // Check with and without worktree suffix
+            const files = existsSync(sessionsDir) ? readdirSync(sessionsDir) : [];
+            if (files.some(f => f.startsWith(hash) && f.endsWith(".cleanup"))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false; // default: persist (safer than deleting)
+    }
+}
 function getStore() {
-    if (!_store)
-        _store = new ContentStore();
+    if (!_store) {
+        const dbPath = getStorePath();
+        // Fresh session: delete old store DB for clean slate
+        if (isFreshStart()) {
+            for (const suffix of ["", "-wal", "-shm"]) {
+                try {
+                    unlinkSync(dbPath + suffix);
+                }
+                catch { /* may not exist */ }
+            }
+        }
+        _store = new ContentStore(dbPath);
+        // One-time startup cleanup: remove stale content DBs (>14 days)
+        try {
+            const contentDir = join(homedir(), ".context-mode", "content");
+            cleanupStaleContentDBs(contentDir, 14);
+            _store.cleanupStaleSources(14);
+        }
+        catch { /* best-effort */ }
+        // Also clean old PID-based DBs from migration
+        cleanupStaleDBs();
+    }
     maybeIndexSessionEvents(_store);
     return _store;
 }
@@ -978,8 +1043,35 @@ server.registerTool("ctx_fetch_and_index", {
             .string()
             .optional()
             .describe("Label for the indexed content (e.g., 'React useEffect docs', 'Supabase Auth API')"),
+        force: z
+            .boolean()
+            .optional()
+            .describe("Skip cache and re-fetch even if content was recently indexed"),
     }),
-}, async ({ url, source }) => {
+}, async ({ url, source, force }) => {
+    // TTL cache: if source was indexed within 24h, return cached hint
+    if (!force) {
+        const store = getStore();
+        const label = source ?? url;
+        const meta = store.getSourceMeta(label);
+        if (meta) {
+            const indexedAt = new Date(meta.indexedAt + "Z"); // SQLite datetime is UTC without Z
+            const ageMs = Date.now() - indexedAt.getTime();
+            const TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+            if (ageMs < TTL_MS) {
+                const ageHours = Math.floor(ageMs / (60 * 60 * 1000));
+                const ageMin = Math.floor(ageMs / (60 * 1000));
+                const ageStr = ageHours > 0 ? `${ageHours}h ago` : ageMin > 0 ? `${ageMin}m ago` : "just now";
+                return trackResponse("ctx_fetch_and_index", {
+                    content: [{
+                            type: "text",
+                            text: `Cached: **${meta.label}** — ${meta.chunkCount} sections, indexed ${ageStr} (fresh, TTL: 24h).\nTo refresh: call ctx_fetch_and_index again with \`force: true\`.\n\nYou MUST call search() to answer questions about this content — this cached response contains no content.\nUse: search(queries: [...], source: "${meta.label}")`,
+                        }],
+                });
+            }
+            // Stale (>24h) — fall through to re-fetch silently
+        }
+    }
     // Generate a unique temp file path for the subprocess to write fetched content.
     // This bypasses the executor's 100KB stdout truncation — content goes file→handler directly.
     const outputPath = join(tmpdir(), `ctx-fetch-${Date.now()}-${Math.random().toString(36).slice(2)}.dat`);
@@ -1500,7 +1592,7 @@ async function main() {
     const shutdown = () => {
         executor.cleanupBackgrounded();
         if (_store)
-            _store.cleanup();
+            _store.close(); // persist DB for --continue sessions
     };
     const gracefulShutdown = async () => {
         shutdown();

package/build/store.d.ts

@@ -13,6 +13,11 @@ export type { IndexResult, SearchResult, StoreStats } from "./types.js";
  * Remove stale DB files from previous sessions whose processes no longer exist.
  */
 export declare function cleanupStaleDBs(): number;
+/**
+ * Clean up stale per-project content store DBs older than maxAgeDays.
+ * Scans the given directory for *.db files and checks mtime.
+ */
+export declare function cleanupStaleContentDBs(contentDir: string, maxAgeDays: number): number;
 export declare class ContentStore {
     #private;
     constructor(dbPath?: string);
@@ -41,6 +46,12 @@ export declare class ContentStore {
     searchTrigram(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose"): SearchResult[];
     fuzzyCorrect(query: string): string | null;
     searchWithFallback(query: string, limit?: number, source?: string, contentType?: "code" | "prose"): SearchResult[];
+    getSourceMeta(label: string): {
+        label: string;
+        chunkCount: number;
+        codeChunkCount: number;
+        indexedAt: string;
+    } | null;
     listSources(): Array<{
         label: string;
         chunkCount: number;
@@ -52,5 +63,12 @@ export declare class ContentStore {
     getChunksBySource(sourceId: number): SearchResult[];
     getDistinctiveTerms(sourceId: number, maxTerms?: number): string[];
     getStats(): StoreStats;
+    /**
+     * Delete sources (and their chunks) older than maxAgeDays.
+     * Returns count of deleted sources.
+     */
+    cleanupStaleSources(maxAgeDays: number): number;
+    /** Get DB file size in bytes. */
+    getDBSizeBytes(): number;
     close(): void;
 }

package/build/store.js

@@ -7,8 +7,8 @@
  * Use for documentation, API references, and any content where
  * you need EXACT text later — not summaries.
  */
-import { loadDatabase, applyWALPragmas } from "./db-base.js";
-import { readFileSync, readdirSync, unlinkSync } from "node:fs";
+import { loadDatabase, applyWALPragmas, closeDB } from "./db-base.js";
+import { readFileSync, readdirSync, unlinkSync, existsSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 // ─────────────────────────────────────────────────────────
@@ -116,6 +116,37 @@ export function cleanupStaleDBs() {
     catch { /* ignore readdir errors */ }
     return cleaned;
 }
+/**
+ * Clean up stale per-project content store DBs older than maxAgeDays.
+ * Scans the given directory for *.db files and checks mtime.
+ */
+export function cleanupStaleContentDBs(contentDir, maxAgeDays) {
+    let cleaned = 0;
+    try {
+        if (!existsSync(contentDir))
+            return 0;
+        const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+        const files = readdirSync(contentDir).filter(f => f.endsWith(".db"));
+        for (const file of files) {
+            try {
+                const filePath = join(contentDir, file);
+                const mtime = statSync(filePath).mtimeMs;
+                if (mtime < cutoff) {
+                    for (const suffix of ["", "-wal", "-shm"]) {
+                        try {
+                            unlinkSync(filePath + suffix);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    cleaned++;
+                }
+            }
+            catch { /* ignore per-file errors */ }
+        }
+    }
+    catch { /* ignore readdir errors */ }
+    return cleaned;
+}
 // ── Proximity helpers (pure functions) ──
 /** Find all positions of a term in text. */
 function findAllPositions(text, term) {
@@ -194,6 +225,7 @@ export class ContentStore {
     #stmtSourceChunkCount;
     #stmtChunkContent;
     #stmtStats;
+    #stmtSourceMeta;
     constructor(dbPath) {
         const Database = loadDatabase();
         this.#dbPath =
@@ -385,6 +417,7 @@ export class ContentStore {
        ORDER BY c.rowid`);
         this.#stmtSourceChunkCount = this.#db.prepare("SELECT chunk_count FROM sources WHERE id = ?");
         this.#stmtChunkContent = this.#db.prepare("SELECT content FROM chunks WHERE source_id = ?");
+        this.#stmtSourceMeta = this.#db.prepare("SELECT label, chunk_count, code_chunk_count, indexed_at FROM sources WHERE label = ?");
         this.#stmtStats = this.#db.prepare(`
       SELECT
         (SELECT COUNT(*) FROM sources) AS sources,
@@ -648,6 +681,12 @@ export class ContentStore {
         return [];
     }
     // ── Sources ──
+    getSourceMeta(label) {
+        const row = this.#stmtSourceMeta.get(label);
+        if (!row)
+            return null;
+        return { label: row.label, chunkCount: row.chunk_count, codeChunkCount: row.code_chunk_count, indexedAt: row.indexed_at };
+    }
     listSources() {
         return this.#stmtListSources.all();
     }
@@ -711,8 +750,33 @@ export class ContentStore {
         };
     }
     // ── Cleanup ──
+    /**
+     * Delete sources (and their chunks) older than maxAgeDays.
+     * 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);
+        });
+        const info = cleanup(maxAgeDays);
+        return info.changes;
+    }
+    /** Get DB file size in bytes. */
+    getDBSizeBytes() {
+        try {
+            return statSync(this.#dbPath).size;
+        }
+        catch {
+            return 0;
+        }
+    }
     close() {
-        this.#db.close();
+        closeDB(this.#db); // WAL checkpoint before close — important for persistent DBs
     }
     // ── Vocabulary Extraction ──
     #extractAndStoreVocabulary(content) {