context-mode 0.9.8 → 0.9.10

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
       "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": "0.9.8",
+      "version": "0.9.10",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "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.",
   "author": {
     "name": "Mert Koseoğlu",

package/build/cli.js

@@ -143,8 +143,18 @@ async function doctor() {
     let criticalFails = 0;
     const s = p.spinner();
     s.start("Running diagnostics");
-    const runtimes = detectRuntimes();
-    const available = getAvailableLanguages(runtimes);
+    let runtimes;
+    let available;
+    try {
+        runtimes = detectRuntimes();
+        available = getAvailableLanguages(runtimes);
+    }
+    catch {
+        s.stop("Diagnostics partial");
+        p.log.warn(color.yellow("Could not detect runtimes") + color.dim(" — module may be missing, restart session after upgrade"));
+        p.outro(color.yellow("Doctor could not fully run — try again after restarting Claude Code"));
+        return 1;
+    }
     s.stop("Diagnostics complete");
     // Runtime check
     p.note(getRuntimeSummary(runtimes), "Runtimes");
@@ -189,9 +199,14 @@ async function doctor() {
         }
     }
     catch (err) {
-        criticalFails++;
         const message = err instanceof Error ? err.message : String(err);
-        p.log.error(color.red("Server test: FAIL") + ` — ${message}`);
+        if (message.includes("Cannot find module") || message.includes("MODULE_NOT_FOUND")) {
+            p.log.warn(color.yellow("Server test: SKIP") + color.dim(" — module not available (restart session after upgrade)"));
+        }
+        else {
+            criticalFails++;
+            p.log.error(color.red("Server test: FAIL") + ` — ${message}`);
+        }
     }
     // Hooks installed
     p.log.step("Checking hooks configuration...");
@@ -275,11 +290,16 @@ async function doctor() {
         }
     }
     catch (err) {
-        criticalFails++;
         const message = err instanceof Error ? err.message : String(err);
-        p.log.error(color.red("FTS5 / better-sqlite3: FAIL") +
-            ` — ${message}` +
-            color.dim("\n  Try: npm rebuild better-sqlite3"));
+        if (message.includes("Cannot find module") || message.includes("MODULE_NOT_FOUND")) {
+            p.log.warn(color.yellow("FTS5 / better-sqlite3: SKIP") + color.dim(" — module not available (restart session after upgrade)"));
+        }
+        else {
+            criticalFails++;
+            p.log.error(color.red("FTS5 / better-sqlite3: FAIL") +
+                ` — ${message}` +
+                color.dim("\n  Try: npm rebuild better-sqlite3"));
+        }
     }
     // Version check
     p.log.step("Checking versions...");
@@ -370,34 +390,41 @@ async function upgrade() {
             timeout: 30000,
         });
         s.stop("Built successfully");
-        // Step 3: Install fresh into new version directory (don't touch old dir - process runs from it)
-        s.start("Installing fresh");
+        // Step 3: Update in-place (same directory, no registry changes needed)
+        s.start("Updating files in-place");
+        // Clean stale version dirs from previous upgrade attempts
         const cacheParentMatch = pluginRoot.match(/^(.*[\\/]plugins[\\/]cache[\\/][^\\/]+[\\/][^\\/]+[\\/])/);
-        const freshDir = cacheParentMatch
-            ? resolve(cacheParentMatch[1], newVersion)
-            : pluginRoot;
-        // If fresh dir is different from current, create it. Otherwise update in-place.
-        if (freshDir !== pluginRoot) {
-            rmSync(freshDir, { recursive: true, force: true });
-            cpSync(srcDir, freshDir, { recursive: true });
-            pluginRoot = freshDir;
-        }
-        else {
-            // Same dir — copy files in-place
-            const items = [
-                "build", "src", "hooks", "skills", ".claude-plugin",
-                "start.mjs", "server.bundle.mjs", "package.json", ".mcp.json",
-            ];
-            for (const item of items) {
-                try {
-                    rmSync(resolve(pluginRoot, item), { recursive: true, force: true });
-                    cpSync(resolve(srcDir, item), resolve(pluginRoot, item), { recursive: true });
+        if (cacheParentMatch) {
+            const cacheParent = cacheParentMatch[1];
+            const myDir = pluginRoot.replace(cacheParent, "").replace(/[\\/]/g, "");
+            try {
+                const oldDirs = readdirSync(cacheParent).filter(d => d !== myDir);
+                for (const d of oldDirs) {
+                    try {
+                        rmSync(resolve(cacheParent, d), { recursive: true, force: true });
+                    }
+                    catch { /* skip */ }
+                }
+                if (oldDirs.length > 0) {
+                    p.log.info(color.dim(`  Cleaned ${oldDirs.length} stale cache dir(s)`));
                 }
-                catch { /* some files may not exist */ }
             }
+            catch { /* parent may not exist */ }
         }
-        s.stop(color.green(`Installed to ${freshDir.split("/").pop() ?? newVersion}`));
-        // Install production deps in fresh dir
+        // Copy new files over old ones — same path, no registry update needed
+        const items = [
+            "build", "src", "hooks", "skills", ".claude-plugin",
+            "start.mjs", "server.bundle.mjs", "package.json", ".mcp.json",
+        ];
+        for (const item of items) {
+            try {
+                rmSync(resolve(pluginRoot, item), { recursive: true, force: true });
+                cpSync(resolve(srcDir, item), resolve(pluginRoot, item), { recursive: true });
+            }
+            catch { /* some files may not exist in source */ }
+        }
+        s.stop(color.green(`Updated in-place to v${newVersion}`));
+        // Install production deps (rebuild native modules if needed)
         s.start("Installing production dependencies");
         execSync("npm install --production --no-audit --no-fund", {
             cwd: pluginRoot,
@@ -405,65 +432,6 @@ async function upgrade() {
             timeout: 60000,
         });
         s.stop("Dependencies ready");
-        // Step 4: Update installed_plugins.json via spawned script (works from any old version)
-        s.start("Updating plugin registry");
-        try {
-            const scriptPath = resolve(tmpDir + "-post-upgrade.mjs");
-            const scriptContent = [
-                `import { readFileSync, writeFileSync, readdirSync, rmSync as rm } from "fs";`,
-                `import { resolve } from "path";`,
-                `import { homedir } from "os";`,
-                `const pluginRoot = ${JSON.stringify(pluginRoot)};`,
-                `const newVersion = ${JSON.stringify(newVersion)};`,
-                `const ipPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");`,
-                `try {`,
-                `  const ipRaw = JSON.parse(readFileSync(ipPath, "utf-8"));`,
-                `  const plugins = ipRaw.plugins || {};`,
-                `  let updated = false;`,
-                `  for (const [key, entries] of Object.entries(plugins)) {`,
-                `    if (!key.toLowerCase().includes("context-mode")) continue;`,
-                `    for (const entry of entries) {`,
-                `      entry.installPath = pluginRoot;`,
-                `      entry.version = newVersion;`,
-                `      entry.lastUpdated = new Date().toISOString();`,
-                `      updated = true;`,
-                `    }`,
-                `  }`,
-                `  if (updated) {`,
-                `    writeFileSync(ipPath, JSON.stringify(ipRaw, null, 2) + "\\n", "utf-8");`,
-                `    console.log("REGISTRY_UPDATED");`,
-                `  }`,
-                `} catch (e) { console.error("REGISTRY_FAILED:" + e.message); }`,
-                `const curDir = pluginRoot.split(/[\\/\\\\]/).pop();`,
-                `const parDir = pluginRoot.replace(/[\\/\\\\][^\\/\\\\]+$/, "");`,
-                `try {`,
-                `  for (const d of readdirSync(parDir).filter(x => x !== curDir)) {`,
-                `    try { rm(resolve(parDir, d), { recursive: true, force: true }); console.log("CLEANED:" + d); } catch {}`,
-                `  }`,
-                `} catch {}`,
-            ].join("\n");
-            writeFileSync(scriptPath, scriptContent, "utf-8");
-            const result = execSync(`node ${scriptPath}`, {
-                stdio: "pipe",
-                timeout: 10000,
-                encoding: "utf-8",
-            });
-            try {
-                rmSync(scriptPath, { force: true });
-            }
-            catch { /* ignore */ }
-            if (result.includes("REGISTRY_UPDATED")) {
-                s.stop(color.green("Plugin registry updated"));
-                changes.push("Updated plugin registry");
-            }
-            else {
-                s.stop(color.yellow("Plugin registry unchanged"));
-            }
-        }
-        catch (err) {
-            s.stop(color.yellow("Plugin registry update skipped"));
-            p.log.warn(color.yellow("Could not update plugin registry") + color.dim(` — ${err instanceof Error ? err.message : String(err)}`));
-        }
         // Update global npm package from same GitHub source
         s.start("Updating npm global package");
         try {
@@ -578,12 +546,19 @@ async function upgrade() {
     else {
         p.log.info(color.dim("No changes were needed."));
     }
-    // Step 7: Run doctor
+    // Step 7: Run doctor from updated pluginRoot
     p.log.step("Running doctor to verify...");
     console.log();
-    const doctorCode = await doctor();
-    if (doctorCode !== 0) {
-        process.exit(doctorCode);
+    try {
+        execSync(`node "${resolve(pluginRoot, "build", "cli.js")}" doctor`, {
+            stdio: "inherit",
+            timeout: 30000,
+            cwd: pluginRoot,
+        });
+    }
+    catch {
+        p.log.warn(color.yellow("Doctor had warnings") +
+            color.dim(" — restart your Claude Code session to pick up the new version"));
     }
 }
 /* -------------------------------------------------------

package/hooks/pretooluse.mjs

@@ -6,6 +6,44 @@
  * Cross-platform (Windows/macOS/Linux) — no bash/jq dependency.
  */
 
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve, dirname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir, tmpdir } from "node:os";
+
+// ─── Self-heal registry (runs once per session via marker file) ───
+try {
+  const marker = resolve(tmpdir(), "context-mode-registry-healed");
+  if (!existsSync(marker)) {
+    const hookDir = dirname(fileURLToPath(import.meta.url));
+    const myRoot = resolve(hookDir, "..");
+    const myVersion = basename(myRoot);
+
+    if (/^\d+\.\d+\.\d+/.test(myVersion)) {
+      const ipPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+      const ip = JSON.parse(readFileSync(ipPath, "utf-8"));
+      let fixed = false;
+
+      for (const [key, entries] of Object.entries(ip.plugins || {})) {
+        if (!key.toLowerCase().includes("context-mode")) continue;
+        for (const entry of entries) {
+          if (entry.installPath !== myRoot) {
+            entry.installPath = myRoot;
+            entry.version = myVersion;
+            entry.lastUpdated = new Date().toISOString();
+            fixed = true;
+          }
+        }
+      }
+
+      if (fixed) {
+        writeFileSync(ipPath, JSON.stringify(ip, null, 2) + "\n", "utf-8");
+      }
+      writeFileSync(marker, Date.now().toString(), "utf-8");
+    }
+  }
+} catch { /* best effort — don't block hook */ }
+
 let raw = "";
 process.stdin.setEncoding("utf-8");
 for await (const chunk of process.stdin) raw += chunk;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "type": "module",
   "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution, FTS5 knowledge base, and intent-driven search.",
   "author": "Mert Koseoğlu",

package/skills/upgrade/SKILL.md

@@ -18,14 +18,29 @@ Pull latest from GitHub and reinstall the plugin.
    ```
    node "<PLUGIN_ROOT>/build/cli.js" upgrade
    ```
-3. **IMPORTANT**: After the Bash tool completes, re-display the key results as markdown text directly in the conversation so the user sees them without expanding the tool output. Format as:
+3. **Registry verification** (CRITICAL — do this even if upgrade reported success):
+   Run a Bash command that does ALL of the following in a single `node -e` script:
+   - Read `~/.claude/plugins/installed_plugins.json`
+   - Find the `context-mode@claude-context-mode` entry (or any key containing `context-mode`)
+   - List directories in `~/.claude/plugins/cache/claude-context-mode/context-mode/`
+   - Find the newest semver directory (e.g., `0.9.9` > `0.7.0`)
+   - If `installPath` does NOT already point to the newest directory, update:
+     - `installPath` → full path to newest version dir
+     - `version` → the newest version string
+     - `lastUpdated` → `new Date().toISOString()`
+   - Write updated JSON back to the file
+   - Print what was changed (or "already correct")
+
+4. **IMPORTANT**: After the Bash tool completes, re-display the key results as markdown text directly in the conversation so the user sees them without expanding the tool output. Format as:
    ```
    ## context-mode upgrade
    - [x] Pulled latest from GitHub
-   - [x] Built and installed v0.6.2
+   - [x] Built and installed v0.9.9
    - [x] npm global updated
    - [x] Hooks configured
    - [x] Permissions set
+   - [x] Registry verified
    - [x] Doctor: all checks PASS
    ```
    Use `[x]` for success, `[ ]` for failure. Show the actual version numbers and any warnings.
+   Tell the user to **restart their Claude Code session** to pick up the new version.

package/start.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 process.chdir(__dirname);
@@ -11,6 +12,56 @@ if (!process.env.CLAUDE_PROJECT_DIR) {
   process.env.CLAUDE_PROJECT_DIR = process.cwd();
 }
 
+// Self-heal: if a newer version dir exists, update registry so next session uses it
+const cacheMatch = __dirname.match(
+  /^(.*[\/\\]plugins[\/\\]cache[\/\\][^\/\\]+[\/\\][^\/\\]+[\/\\])([^\/\\]+)$/,
+);
+if (cacheMatch) {
+  try {
+    const cacheParent = cacheMatch[1];
+    const myVersion = cacheMatch[2];
+    const dirs = readdirSync(cacheParent).filter((d) =>
+      /^\d+\.\d+\.\d+/.test(d),
+    );
+    if (dirs.length > 1) {
+      dirs.sort((a, b) => {
+        const pa = a.split(".").map(Number);
+        const pb = b.split(".").map(Number);
+        for (let i = 0; i < 3; i++) {
+          if ((pa[i] ?? 0) !== (pb[i] ?? 0))
+            return (pa[i] ?? 0) - (pb[i] ?? 0);
+        }
+        return 0;
+      });
+      const newest = dirs[dirs.length - 1];
+      if (newest && newest !== myVersion) {
+        const ipPath = resolve(
+          homedir(),
+          ".claude",
+          "plugins",
+          "installed_plugins.json",
+        );
+        const ip = JSON.parse(readFileSync(ipPath, "utf-8"));
+        for (const [key, entries] of Object.entries(ip.plugins || {})) {
+          if (!key.toLowerCase().includes("context-mode")) continue;
+          for (const entry of entries) {
+            entry.installPath = resolve(cacheParent, newest);
+            entry.version = newest;
+            entry.lastUpdated = new Date().toISOString();
+          }
+        }
+        writeFileSync(
+          ipPath,
+          JSON.stringify(ip, null, 2) + "\n",
+          "utf-8",
+        );
+      }
+    }
+  } catch {
+    /* best effort — don't block server startup */
+  }
+}
+
 // Ensure native module is available
 if (!existsSync(resolve(__dirname, "node_modules", "better-sqlite3"))) {
   try {