context-mode 0.7.3 → 0.8.0

package/.claude-plugin/marketplace.json

@@ -12,8 +12,8 @@
     {
       "name": "context-mode",
       "source": "./",
-      "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 10 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "0.7.2",
+      "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.8.0",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "context-mode",
-  "version": "0.7.2",
-  "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 10 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
+  "version": "0.8.0",
+  "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",
     "url": "https://github.com/mksglu"

package/README.md

@@ -68,7 +68,7 @@ Code Mode showed that tool definitions can be compressed by 99.9%. Context Mode
 
 Each `execute` call spawns an isolated subprocess with its own process boundary. Scripts can't access each other's memory or state. The subprocess runs your code, captures stdout, and only that stdout enters the conversation context. The raw data — log files, API responses, snapshots — never leaves the sandbox.
 
-Ten language runtimes are available: JavaScript, TypeScript, Python, Shell, Ruby, Go, Rust, PHP, Perl, R. Bun is auto-detected for 3-5x faster JS/TS execution.
+Eleven language runtimes are available: JavaScript, TypeScript, Python, Shell, Ruby, Go, Rust, PHP, Perl, R, and Elixir. Bun is auto-detected for 3-5x faster JS/TS execution.
 
 Authenticated CLIs work through credential passthrough — `gh`, `aws`, `gcloud`, `kubectl`, `docker` inherit environment variables and config paths without exposing them to the conversation.
 
@@ -199,6 +199,12 @@ npm test              # run tests
 npm run test:all      # full suite
 ```
 
+## Contributors
+
+<a href="https://github.com/mksglu/claude-context-mode/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=mksglu/claude-context-mode" />
+</a>
+
 ## License
 
 MIT

package/build/executor.d.ts

@@ -17,6 +17,7 @@ export declare class PolyglotExecutor {
     #private;
     constructor(opts?: {
         maxOutputBytes?: number;
+        hardCapBytes?: number;
         projectRoot?: string;
         runtimes?: RuntimeMap;
     });

package/build/executor.js

@@ -1,15 +1,17 @@
 var _a;
 import { spawn, execSync } from "node:child_process";
-import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { mkdtempSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { detectRuntimes, buildCommand, } from "./runtime.js";
 export class PolyglotExecutor {
     #maxOutputBytes;
+    #hardCapBytes;
     #projectRoot;
     #runtimes;
     constructor(opts) {
         this.#maxOutputBytes = opts?.maxOutputBytes ?? 102_400;
+        this.#hardCapBytes = opts?.hardCapBytes ?? 100 * 1024 * 1024; // 100MB
         this.#projectRoot = opts?.projectRoot ?? process.cwd();
         this.#runtimes = opts?.runtimes ?? detectRuntimes();
     }
@@ -50,6 +52,7 @@ export class PolyglotExecutor {
             php: "php",
             perl: "pl",
             r: "R",
+            elixir: "exs",
         };
         // Go needs a main package wrapper if not present
         if (language === "go" && !code.includes("package ")) {
@@ -59,6 +62,11 @@ export class PolyglotExecutor {
         if (language === "php" && !code.trimStart().startsWith("<?")) {
             code = `<?php\n${code}`;
         }
+        // Elixir: prepend compiled BEAM paths when inside a Mix project
+        if (language === "elixir" && existsSync(join(this.#projectRoot, "mix.exs"))) {
+            const escaped = JSON.stringify(join(this.#projectRoot, "_build/dev/lib"));
+            code = `Path.wildcard(Path.join(${escaped}, "*/ebin"))\n|> Enum.each(&Code.prepend_path/1)\n\n${code}`;
+        }
         const fp = join(tmpDir, `script.${extMap[language]}`);
         if (language === "shell") {
             writeFileSync(fp, code, { encoding: "utf-8", mode: 0o700 });
@@ -139,22 +147,41 @@ export class PolyglotExecutor {
                 timedOut = true;
                 proc.kill("SIGKILL");
             }, timeout);
-            // Collect ALL output in full — smart truncation happens after
-            // process exits so we can keep head + tail.
-            // OOM is bounded by timeout (default 30s) and maxOutputBytes
-            // (used only for truncation threshold, not stream limiting).
+            // Stream-level byte cap: kill the process once combined stdout+stderr
+            // exceeds hardCapBytes. Without this, a command like `yes` or
+            // `cat /dev/urandom | base64` can accumulate gigabytes in memory
+            // before the timeout fires.
             const stdoutChunks = [];
             const stderrChunks = [];
+            let totalBytes = 0;
+            let capExceeded = false;
             proc.stdout.on("data", (chunk) => {
-                stdoutChunks.push(chunk);
+                totalBytes += chunk.length;
+                if (totalBytes <= this.#hardCapBytes) {
+                    stdoutChunks.push(chunk);
+                }
+                else if (!capExceeded) {
+                    capExceeded = true;
+                    proc.kill("SIGKILL");
+                }
             });
             proc.stderr.on("data", (chunk) => {
-                stderrChunks.push(chunk);
+                totalBytes += chunk.length;
+                if (totalBytes <= this.#hardCapBytes) {
+                    stderrChunks.push(chunk);
+                }
+                else if (!capExceeded) {
+                    capExceeded = true;
+                    proc.kill("SIGKILL");
+                }
             });
             proc.on("close", (exitCode) => {
                 clearTimeout(timer);
                 const rawStdout = Buffer.concat(stdoutChunks).toString("utf-8");
-                const rawStderr = Buffer.concat(stderrChunks).toString("utf-8");
+                let rawStderr = Buffer.concat(stderrChunks).toString("utf-8");
+                if (capExceeded) {
+                    rawStderr += `\n[output capped at ${(this.#hardCapBytes / 1024 / 1024).toFixed(0)}MB — process killed]`;
+                }
                 const max = this.#maxOutputBytes;
                 const stdout = _a.#smartTruncate(rawStdout, max);
                 const stderr = _a.#smartTruncate(rawStderr, max);
@@ -235,8 +262,11 @@ export class PolyglotExecutor {
                 return `const FILE_CONTENT_PATH = ${escaped};\nconst FILE_CONTENT = require("fs").readFileSync(FILE_CONTENT_PATH, "utf-8");\n${code}`;
             case "python":
                 return `FILE_CONTENT_PATH = ${escaped}\nwith open(FILE_CONTENT_PATH, "r") as _f:\n    FILE_CONTENT = _f.read()\n${code}`;
-            case "shell":
-                return `FILE_CONTENT_PATH=${escaped}\nFILE_CONTENT=$(cat ${escaped})\n${code}`;
+            case "shell": {
+                // Single-quote the path to prevent $, backtick, and ! expansion
+                const sq = "'" + absolutePath.replace(/'/g, "'\\''") + "'";
+                return `FILE_CONTENT_PATH=${sq}\nFILE_CONTENT=$(cat ${sq})\n${code}`;
+            }
             case "ruby":
                 return `FILE_CONTENT_PATH = ${escaped}\nFILE_CONTENT = File.read(FILE_CONTENT_PATH)\n${code}`;
             case "go":
@@ -249,6 +279,8 @@ export class PolyglotExecutor {
                 return `my $FILE_CONTENT_PATH = ${escaped};\nopen(my $fh, '<', $FILE_CONTENT_PATH) or die "Cannot open: $!";\nmy $FILE_CONTENT = do { local $/; <$fh> };\nclose($fh);\n${code}`;
             case "r":
                 return `FILE_CONTENT_PATH <- ${escaped}\nFILE_CONTENT <- readLines(FILE_CONTENT_PATH, warn=FALSE)\nFILE_CONTENT <- paste(FILE_CONTENT, collapse="\\n")\n${code}`;
+            case "elixir":
+                return `file_content_path = ${escaped}\nfile_content = File.read!(file_content_path)\n${code}`;
         }
     }
 }

package/build/runtime.d.ts

@@ -1,4 +1,4 @@
-export type Language = "javascript" | "typescript" | "python" | "shell" | "ruby" | "go" | "rust" | "php" | "perl" | "r";
+export type Language = "javascript" | "typescript" | "python" | "shell" | "ruby" | "go" | "rust" | "php" | "perl" | "r" | "elixir";
 export interface RuntimeInfo {
     command: string;
     available: boolean;
@@ -16,6 +16,7 @@ export interface RuntimeMap {
     php: string | null;
     perl: string | null;
     r: string | null;
+    elixir: string | null;
 }
 export declare function detectRuntimes(): RuntimeMap;
 export declare function hasBunRuntime(): boolean;

package/build/runtime.js

@@ -48,6 +48,7 @@ export function detectRuntimes() {
             : commandExists("r")
                 ? "r"
                 : null,
+        elixir: commandExists("elixir") ? "elixir" : null,
     };
 }
 export function hasBunRuntime() {
@@ -83,6 +84,8 @@ export function getRuntimeSummary(runtimes) {
         lines.push(`  Perl:       ${runtimes.perl} (${getVersion(runtimes.perl)})`);
     if (runtimes.r)
         lines.push(`  R:          ${runtimes.r} (${getVersion(runtimes.r)})`);
+    if (runtimes.elixir)
+        lines.push(`  Elixir:     ${runtimes.elixir} (${getVersion(runtimes.elixir)})`);
     if (!bunPreferred) {
         lines.push("");
         lines.push("  Tip: Install Bun for 3-5x faster JS/TS execution → https://bun.sh");
@@ -107,6 +110,8 @@ export function getAvailableLanguages(runtimes) {
         langs.push("perl");
     if (runtimes.r)
         langs.push("r");
+    if (runtimes.elixir)
+        langs.push("elixir");
     return langs;
 }
 export function buildCommand(runtimes, language, filePath) {
@@ -163,5 +168,10 @@ export function buildCommand(runtimes, language, filePath) {
                 throw new Error("R not available. Install R / Rscript.");
             }
             return [runtimes.r, filePath];
+        case "elixir":
+            if (!runtimes.elixir) {
+                throw new Error("Elixir not available. Install elixir.");
+            }
+            return ["elixir", filePath];
     }
 }

package/build/server.js

@@ -5,14 +5,17 @@ import { z } from "zod";
 import { PolyglotExecutor } from "./executor.js";
 import { ContentStore, cleanupStaleDBs } from "./store.js";
 import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime, } from "./runtime.js";
-const VERSION = "0.7.3";
+const VERSION = "0.8.0";
 const runtimes = detectRuntimes();
 const available = getAvailableLanguages(runtimes);
 const server = new McpServer({
     name: "context-mode",
     version: VERSION,
 });
-const executor = new PolyglotExecutor({ runtimes });
+const executor = new PolyglotExecutor({
+    runtimes,
+    projectRoot: process.env.CLAUDE_PROJECT_DIR,
+});
 // Lazy singleton — no DB overhead unless index/search is used
 let _store = null;
 function getStore() {
@@ -115,11 +118,12 @@ server.registerTool("execute", {
             "php",
             "perl",
             "r",
+            "elixir",
         ])
             .describe("Runtime language"),
         code: z
             .string()
-            .describe("Source code to execute. Use console.log (JS/TS), print (Python/Ruby/Perl/R), echo (Shell), echo (PHP), or fmt.Println (Go) to output a summary to context."),
+            .describe("Source code to execute. Use console.log (JS/TS), print (Python/Ruby/Perl/R), echo (Shell), echo (PHP), fmt.Println (Go), or IO.puts (Elixir) to output a summary to context."),
         timeout: z
             .number()
             .optional()
@@ -239,74 +243,40 @@ function intentSearch(stdout, intent, source, maxResults = 5) {
     // Index into the PERSISTENT store so user can search() later
     const persistent = getStore();
     const indexed = persistent.indexPlainText(stdout, source);
-    // Search with an ephemeral store to find matching section titles
-    const ephemeral = new ContentStore(":memory:");
-    try {
-        ephemeral.indexPlainText(stdout, source);
-        let results = ephemeral.search(intent, maxResults);
-        // Score-based relaxed search: search ALL words, rank by match count
-        if (results.length === 0) {
-            const words = intent.trim().split(/\s+/).filter(w => w.length > 2).slice(0, 20);
-            if (words.length > 0) {
-                const sectionScores = new Map();
-                for (const word of words) {
-                    const wordResults = ephemeral.search(word, 10);
-                    for (const r of wordResults) {
-                        const existing = sectionScores.get(r.title);
-                        if (existing) {
-                            existing.score += 1;
-                            if (r.rank < existing.bestRank) {
-                                existing.bestRank = r.rank;
-                                existing.result = r;
-                            }
-                        }
-                        else {
-                            sectionScores.set(r.title, { result: r, score: 1, bestRank: r.rank });
-                        }
-                    }
-                }
-                results = Array.from(sectionScores.values())
-                    .sort((a, b) => b.score - a.score || a.bestRank - b.bestRank)
-                    .slice(0, maxResults)
-                    .map(s => s.result);
-            }
-        }
-        // Extract distinctive terms as vocabulary hints for the LLM
-        const distinctiveTerms = persistent.getDistinctiveTerms(indexed.sourceId);
-        if (results.length === 0) {
-            const lines = [
-                `Indexed ${indexed.totalChunks} sections from "${source}" into knowledge base.`,
-                `No sections matched intent "${intent}" in ${totalLines}-line output (${(totalBytes / 1024).toFixed(1)}KB).`,
-            ];
-            if (distinctiveTerms.length > 0) {
-                lines.push("");
-                lines.push(`Searchable terms: ${distinctiveTerms.join(", ")}`);
-            }
-            lines.push("");
-            lines.push("Use search() to explore the indexed content.");
-            return lines.join("\n");
-        }
-        // Return ONLY titles + first-line previews — not full content
+    // Search the persistent store directly (porter → trigram → fuzzy)
+    let results = persistent.searchWithFallback(intent, maxResults, source);
+    // Extract distinctive terms as vocabulary hints for the LLM
+    const distinctiveTerms = persistent.getDistinctiveTerms(indexed.sourceId);
+    if (results.length === 0) {
         const lines = [
             `Indexed ${indexed.totalChunks} sections from "${source}" into knowledge base.`,
-            `${results.length} sections matched "${intent}" (${totalLines} lines, ${(totalBytes / 1024).toFixed(1)}KB):`,
-            "",
+            `No sections matched intent "${intent}" in ${totalLines}-line output (${(totalBytes / 1024).toFixed(1)}KB).`,
         ];
-        for (const r of results) {
-            const preview = r.content.split("\n")[0].slice(0, 120);
-            lines.push(`  - ${r.title}: ${preview}`);
-        }
         if (distinctiveTerms.length > 0) {
             lines.push("");
             lines.push(`Searchable terms: ${distinctiveTerms.join(", ")}`);
         }
         lines.push("");
-        lines.push("Use search(queries: [...]) to retrieve full content of any section.");
+        lines.push("Use search() to explore the indexed content.");
         return lines.join("\n");
     }
-    finally {
-        ephemeral.close();
+    // Return ONLY titles + first-line previews — not full content
+    const lines = [
+        `Indexed ${indexed.totalChunks} sections from "${source}" into knowledge base.`,
+        `${results.length} sections matched "${intent}" (${totalLines} lines, ${(totalBytes / 1024).toFixed(1)}KB):`,
+        "",
+    ];
+    for (const r of results) {
+        const preview = r.content.split("\n")[0].slice(0, 120);
+        lines.push(`  - ${r.title}: ${preview}`);
+    }
+    if (distinctiveTerms.length > 0) {
+        lines.push("");
+        lines.push(`Searchable terms: ${distinctiveTerms.join(", ")}`);
     }
+    lines.push("");
+    lines.push("Use search(queries: [...]) to retrieve full content of any section.");
+    return lines.join("\n");
 }
 // ─────────────────────────────────────────────────────────
 // Tool: execute_file
@@ -330,11 +300,12 @@ server.registerTool("execute_file", {
             "php",
             "perl",
             "r",
+            "elixir",
         ])
             .describe("Runtime language"),
         code: z
             .string()
-            .describe("Code to process FILE_CONTENT. Print summary via console.log/print/echo."),
+            .describe("Code to process FILE_CONTENT (file_content in Elixir). Print summary via console.log/print/echo/IO.puts."),
         timeout: z
             .number()
             .optional()
@@ -561,7 +532,7 @@ server.registerTool("search", {
                 sections.push(`## ${q}\n(output cap reached)\n`);
                 continue;
             }
-            const results = store.search(q, effectiveLimit, source);
+            const results = store.searchWithFallback(q, effectiveLimit, source);
             if (results.length === 0) {
                 sections.push(`## ${q}\nNo results found.`);
                 continue;
@@ -841,16 +812,11 @@ server.registerTool("batch_execute", {
                 queryResults.push(`## ${query}\n(output cap reached — use search(queries: ["${query}"]) for details)\n`);
                 continue;
             }
-            // Tier 1: scoped search (within this batch's source)
-            let results = store.search(query, 3, source);
-            // Tier 2: boosted with section titles
-            if (results.length === 0 && sectionTitles.length > 0) {
-                const boosted = `${query} ${sectionTitles.join(" ")}`;
-                results = store.search(boosted, 3, source);
-            }
-            // Tier 3: global fallback (no source filter)
+            // Tier 1: scoped search with fallback (porter → trigram → fuzzy)
+            let results = store.searchWithFallback(query, 3, source);
+            // Tier 2: global fallback (no source filter)
             if (results.length === 0) {
-                results = store.search(query, 3);
+                results = store.searchWithFallback(query, 3);
             }
             queryResults.push(`## ${query}`);
             queryResults.push("");

package/build/store.js

@@ -423,12 +423,11 @@ export class ContentStore {
         const totalChunks = stats.chunk_count;
         const minAppearances = 2;
         const maxAppearances = Math.max(3, Math.ceil(totalChunks * 0.4));
-        const rows = this.#db
-            .prepare("SELECT content FROM chunks WHERE source_id = ?")
-            .all(sourceId);
+        // Stream chunks one at a time to avoid loading all content into memory
+        const stmt = this.#db.prepare("SELECT content FROM chunks WHERE source_id = ?");
         // Count document frequency (how many sections contain each word)
         const docFreq = new Map();
-        for (const row of rows) {
+        for (const row of stmt.iterate(sourceId)) {
             const words = new Set(row.content
                 .toLowerCase()
                 .split(/[^\p{L}\p{N}_-]+/u)
@@ -476,9 +475,11 @@ export class ContentStore {
             .filter((w) => w.length >= 3 && !STOPWORDS.has(w));
         const unique = [...new Set(words)];
         const insert = this.#db.prepare("INSERT OR IGNORE INTO vocabulary (word) VALUES (?)");
-        for (const word of unique) {
-            insert.run(word);
-        }
+        this.#db.transaction(() => {
+            for (const word of unique) {
+                insert.run(word);
+            }
+        })();
     }
     // ── Chunking ──
     #chunkMarkdown(text) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "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",
@@ -52,7 +52,11 @@
     "test:store": "npx tsx tests/store.test.ts",
     "test:fuzzy": "npx tsx tests/fuzzy-search.test.ts",
     "test:hooks": "npx tsx tests/hook-integration.test.ts",
-    "test:all": "npx tsx tests/executor.test.ts && npx tsx tests/store.test.ts && npx tsx tests/fuzzy-search.test.ts && npx tsx tests/hook-integration.test.ts && npx tsx tests/use-cases.ts && npx tsx tests/context-comparison.ts && npx tsx tests/benchmark.ts && npx tsx tests/ecosystem-benchmark.ts"
+    "test:project-dir": "npx tsx tests/project-dir.test.ts",
+    "test:stream-cap": "npx tsx tests/stream-cap.test.ts",
+    "test:search-wiring": "npx tsx tests/search-wiring.test.ts",
+    "test:search-fallback": "npx tsx tests/search-fallback-integration.test.ts",
+    "test:all": "for f in tests/*.test.ts; do npx tsx \"$f\" || exit 1; done"
   },
   "dependencies": {
     "@clack/prompts": "^1.0.1",

package/skills/doctor/SKILL.md

@@ -16,7 +16,7 @@ Run diagnostics and display results directly in the conversation.
 1. Derive the **plugin root** from this skill's base directory (go up 2 levels — remove `/skills/doctor`).
 2. Run with Bash:
    ```
-   node "<PLUGIN_ROOT>/build/cli.js" doctor
+   npx tsx "<PLUGIN_ROOT>/src/cli.ts" doctor
    ```
 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 a checklist:
    ```

package/skills/upgrade/SKILL.md

@@ -16,7 +16,7 @@ Pull latest from GitHub and reinstall the plugin.
 1. Derive the **plugin root** from this skill's base directory (go up 2 levels — remove `/skills/upgrade`).
 2. Run with Bash:
    ```
-   node "<PLUGIN_ROOT>/build/cli.js" upgrade
+   npx tsx "<PLUGIN_ROOT>/src/cli.ts" 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:
    ```

package/start.sh

@@ -1,14 +1,15 @@
 #!/bin/sh
+CLAUDE_PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
 DIR="$(cd "$(dirname "$0")" && pwd)"
 cd "$DIR"
 
 # Bundle exists (CI-built) — start instantly, install native module in background
 if [ -f server.bundle.mjs ]; then
   [ -d node_modules/better-sqlite3 ] || npm install better-sqlite3 --no-package-lock --no-save --silent 2>/dev/null &
-  exec node server.bundle.mjs
+  CLAUDE_PROJECT_DIR="$CLAUDE_PROJECT_DIR" exec node server.bundle.mjs
 fi
 
 # Fallback: no bundle (dev or npm install) — full build
 [ -d node_modules ] || npm install --silent 2>/dev/null
 [ -f build/server.js ] || npx tsc --silent 2>/dev/null
-exec node build/server.js
+CLAUDE_PROJECT_DIR="$CLAUDE_PROJECT_DIR" exec node build/server.js