context-mode 0.9.8 → 0.9.9

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.9",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "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,9 +390,26 @@ 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: Clean old cache dirs (not our own - we're running from it), then install fresh
         const cacheParentMatch = pluginRoot.match(/^(.*[\\/]plugins[\\/]cache[\\/][^\\/]+[\\/][^\\/]+[\\/])/);
+        if (cacheParentMatch) {
+            const cacheParent = cacheParentMatch[1];
+            const myDir = pluginRoot.replace(cacheParent, "");
+            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} old cache dir(s)`));
+                }
+            }
+            catch { /* parent may not exist */ }
+        }
+        s.start("Installing fresh");
         const freshDir = cacheParentMatch
             ? resolve(cacheParentMatch[1], newVersion)
             : pluginRoot;
@@ -410,7 +447,7 @@ async function upgrade() {
         try {
             const scriptPath = resolve(tmpDir + "-post-upgrade.mjs");
             const scriptContent = [
-                `import { readFileSync, writeFileSync, readdirSync, rmSync as rm } from "fs";`,
+                `import { readFileSync, writeFileSync } from "fs";`,
                 `import { resolve } from "path";`,
                 `import { homedir } from "os";`,
                 `const pluginRoot = ${JSON.stringify(pluginRoot)};`,
@@ -434,13 +471,6 @@ async function upgrade() {
                 `    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}`, {
@@ -578,12 +608,20 @@ async function upgrade() {
     else {
         p.log.info(color.dim("No changes were needed."));
     }
-    // Step 7: Run doctor
+    // Step 7: Run doctor from NEW pluginRoot (not old __dirname)
     p.log.step("Running doctor to verify...");
     console.log();
-    const doctorCode = await doctor();
-    if (doctorCode !== 0) {
-        process.exit(doctorCode);
+    try {
+        const doctorScript = resolve(pluginRoot, "build", "cli.js");
+        execSync(`node "${doctorScript}" 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "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 {