context-mode 0.4.1 → 0.5.0

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 94% of your context window. Sandboxed code execution in 10 languages, FTS5 knowledge base with BM25 ranking, and smart truncation.",
-      "version": "0.4.1",
+      "version": "0.5.0",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Claude Code MCP plugin that saves 94% of your context window. Sandboxed code execution in 10 languages, FTS5 knowledge base with BM25 ranking, and smart truncation.",
   "author": {
     "name": "Mert Koseoğlu",

package/README.md

@@ -75,11 +75,22 @@ Claude calls: execute({ language: "shell", code: "gh pr list --json title,state
 Returns: "3"                  ← 2 bytes instead of 8KB JSON
 ```
 
+**Intent-driven search** (v0.5.0): When you provide an `intent` parameter and output exceeds 5KB, Context Mode uses BM25 search to return only the relevant sections — instead of blind head/tail truncation.
+
+```
+Claude calls: execute({
+  language: "shell",
+  code: "cat /var/log/app.log",
+  intent: "connection refused database error"
+})
+Returns: only the 3 matching log sections (1.5KB) ← instead of 100KB truncated log
+```
+
 Authenticated CLIs work out of the box — `gh`, `aws`, `gcloud`, `kubectl`, `docker` credentials are passed through securely. Bun auto-detected for 3-5x faster JS/TS.
 
 ### `execute_file` — Process Files Without Loading
 
-File contents never enter context. The file is read into a `FILE_CONTENT` variable inside the sandbox.
+File contents never enter context. The file is read into a `FILE_CONTENT` variable inside the sandbox. Also supports `intent` parameter for intent-driven search on large outputs.
 
 ```
 Claude calls: execute_file({ path: "access.log", language: "python", code: "..." })
@@ -214,6 +225,31 @@ Tail (40%): Final output with errors/results
 
 Line-boundary snapping — never cuts mid-line. Error messages at the bottom are always preserved.
 
+### Intent-Driven Search (v0.5.0)
+
+When `execute` or `execute_file` is called with an `intent` parameter and output exceeds 5KB, Context Mode replaces blind truncation with intelligent BM25 search:
+
+```
+Traditional truncation:
+  stdout (100KB) → head(60%) + tail(40%) → ~100KB in context
+  Problem: relevant info in the middle is lost
+
+Intent-driven search:
+  stdout (100KB) → chunk by lines → in-memory FTS5 → search(intent) → 2-5KB relevant sections
+  Result: only what you need enters context
+```
+
+Tested across 4 real-world scenarios:
+
+| Scenario | Smart Truncation | Intent Search | Intent Size | Truncation Size |
+|---|---|---|---|---|
+| Server log error (line 347/500) | **missed** | **found** | 1.5 KB | 5.0 KB |
+| 3 test failures among 200 tests | found 2/3 | **found 3/3** | 2.4 KB | 5.0 KB |
+| 2 build warnings among 300 lines | **missed both** | **found both** | 2.1 KB | 5.0 KB |
+| API auth error (line 743/1000) | **missed** | **found** | 1.2 KB | 4.9 KB |
+
+Smart truncation fails on 3 of 4 scenarios because relevant content is in the dropped middle section. Intent search finds the target every time while using 50-75% fewer bytes.
+
 ### HTML to Markdown Conversion
 
 `fetch_and_index` converts HTML in a subprocess (raw HTML never enters context):
@@ -352,12 +388,13 @@ Just ask naturally — Claude automatically routes through Context Mode when it
 
 ## Test Suite
 
-113 tests across 3 suites:
+99+ tests across 4 suites:
 
 | Suite | Tests | Coverage |
 |---|---|---|
 | Executor | 55 | 10 languages, sandbox, truncation, concurrency, timeouts |
-| ContentStore | 34 | FTS5 schema, BM25 ranking, chunking, stemming, fixtures |
+| ContentStore | 40 | FTS5 schema, BM25 ranking, chunking, stemming, plain text indexing |
+| Intent Search | 4 | Smart truncation vs intent-driven search across 4 real-world scenarios |
 | MCP Integration | 24 | JSON-RPC protocol, all 5 tools, fetch_and_index, errors |
 
 ## Development
@@ -368,8 +405,8 @@ cd claude-context-mode
 npm install
 npm run build
 npm test              # executor (55 tests)
-npm run test:store    # FTS5/BM25 (34 tests)
-npm run test:all      # all suites (113 tests)
+npm run test:store    # FTS5/BM25 (40 tests)
+npm run test:all      # all suites (99+ tests)
 ```
 
 ## License

package/build/server.js

@@ -9,7 +9,7 @@ const runtimes = detectRuntimes();
 const available = getAvailableLanguages(runtimes);
 const server = new McpServer({
     name: "context-mode",
-    version: "0.4.1",
+    version: "0.5.0",
 });
 const executor = new PolyglotExecutor({ runtimes });
 // Lazy singleton — no DB overhead unless index/search is used
@@ -53,8 +53,14 @@ server.registerTool("execute", {
             .optional()
             .default(30000)
             .describe("Max execution time in ms"),
+        intent: z
+            .string()
+            .optional()
+            .describe("What you're looking for in the output. When provided and output is large (>5KB), " +
+            "returns only matching sections via BM25 search instead of truncated output. " +
+            "Example: 'find failing tests', 'HTTP 500 errors', 'memory usage statistics'."),
     }),
-}, async ({ language, code, timeout }) => {
+}, async ({ language, code, timeout, intent }) => {
     try {
         const result = await executor.execute({ language, code, timeout });
         if (result.timedOut) {
@@ -69,19 +75,34 @@ server.registerTool("execute", {
             };
         }
         if (result.exitCode !== 0) {
+            const output = `Exit code: ${result.exitCode}\n\nstdout:\n${result.stdout}\n\nstderr:\n${result.stderr}`;
+            if (intent && intent.trim().length > 0 && Buffer.byteLength(output) > INTENT_SEARCH_THRESHOLD) {
+                return {
+                    content: [
+                        { type: "text", text: intentSearch(output, intent) },
+                    ],
+                    isError: true,
+                };
+            }
             return {
                 content: [
-                    {
-                        type: "text",
-                        text: `Exit code: ${result.exitCode}\n\nstdout:\n${result.stdout}\n\nstderr:\n${result.stderr}`,
-                    },
+                    { type: "text", text: output },
                 ],
                 isError: true,
             };
         }
+        const stdout = result.stdout || "(no output)";
+        // Intent-driven search: if intent provided and output is large enough
+        if (intent && intent.trim().length > 0 && Buffer.byteLength(stdout) > INTENT_SEARCH_THRESHOLD) {
+            return {
+                content: [
+                    { type: "text", text: intentSearch(stdout, intent) },
+                ],
+            };
+        }
         return {
             content: [
-                { type: "text", text: result.stdout || "(no output)" },
+                { type: "text", text: stdout },
             ],
         };
     }
@@ -111,6 +132,36 @@ function indexStdout(stdout, source) {
     };
 }
 // ─────────────────────────────────────────────────────────
+// Helper: intent-driven search on execution output
+// ─────────────────────────────────────────────────────────
+const INTENT_SEARCH_THRESHOLD = 5_000; // bytes — ~80-100 lines
+function intentSearch(stdout, intent, maxResults = 5) {
+    const store = new ContentStore(":memory:");
+    try {
+        const totalLines = stdout.split("\n").length;
+        const totalBytes = Buffer.byteLength(stdout);
+        store.indexPlainText(stdout, "exec-output");
+        const results = store.search(intent, maxResults);
+        if (results.length === 0) {
+            return (`[Intent search: no matches for "${intent}" in ${totalLines}-line output. Returning full output.]\n\n` +
+                stdout);
+        }
+        const totalChunks = store.getStats().chunks;
+        const header = `[Intent search: ${results.length} of ${totalChunks} sections matched "${intent}" from ${totalLines}-line output (${(totalBytes / 1024).toFixed(1)}KB)]`;
+        const formatted = results
+            .map((r, i) => {
+            const matchLabel = i === 0 ? " (best match)" : "";
+            return `--- ${r.title}${matchLabel} ---\n${r.content}`;
+        })
+            .join("\n\n");
+        const footer = `[Full output: ${totalLines} lines / ${(totalBytes / 1024).toFixed(1)}KB. Re-run without intent to see raw output.]`;
+        return `${header}\n\n${formatted}\n\n${footer}`;
+    }
+    finally {
+        store.close();
+    }
+}
+// ─────────────────────────────────────────────────────────
 // Tool: execute_file
 // ─────────────────────────────────────────────────────────
 server.registerTool("execute_file", {
@@ -142,8 +193,13 @@ server.registerTool("execute_file", {
             .optional()
             .default(30000)
             .describe("Max execution time in ms"),
+        intent: z
+            .string()
+            .optional()
+            .describe("What you're looking for in the output. When provided and output is large (>5KB), " +
+            "returns only matching sections via BM25 search instead of truncated output."),
     }),
-}, async ({ path, language, code, timeout }) => {
+}, async ({ path, language, code, timeout, intent }) => {
     try {
         const result = await executor.executeFile({
             path,
@@ -163,19 +219,33 @@ server.registerTool("execute_file", {
             };
         }
         if (result.exitCode !== 0) {
+            const output = `Error processing ${path} (exit ${result.exitCode}):\n${result.stderr || result.stdout}`;
+            if (intent && intent.trim().length > 0 && Buffer.byteLength(output) > INTENT_SEARCH_THRESHOLD) {
+                return {
+                    content: [
+                        { type: "text", text: intentSearch(output, intent) },
+                    ],
+                    isError: true,
+                };
+            }
             return {
                 content: [
-                    {
-                        type: "text",
-                        text: `Error processing ${path} (exit ${result.exitCode}):\n${result.stderr || result.stdout}`,
-                    },
+                    { type: "text", text: output },
                 ],
                 isError: true,
             };
         }
+        const stdout = result.stdout || "(no output)";
+        if (intent && intent.trim().length > 0 && Buffer.byteLength(stdout) > INTENT_SEARCH_THRESHOLD) {
+            return {
+                content: [
+                    { type: "text", text: intentSearch(stdout, intent) },
+                ],
+            };
+        }
         return {
             content: [
-                { type: "text", text: result.stdout || "(no output)" },
+                { type: "text", text: stdout },
             ],
         };
     }

package/build/store.d.ts

@@ -33,6 +33,12 @@ export declare class ContentStore {
         path?: string;
         source?: string;
     }): IndexResult;
+    /**
+     * Index plain-text output (logs, build output, test results) by splitting
+     * into fixed-size line groups. Unlike markdown indexing, this does not
+     * look for headings — it chunks by line count with overlap.
+     */
+    indexPlainText(content: string, source: string, linesPerChunk?: number): IndexResult;
     search(query: string, limit?: number): SearchResult[];
     getStats(): StoreStats;
     close(): void;

package/build/store.js

@@ -94,6 +94,42 @@ export class ContentStore {
             codeChunks,
         };
     }
+    // ── Index Plain Text ──
+    /**
+     * Index plain-text output (logs, build output, test results) by splitting
+     * into fixed-size line groups. Unlike markdown indexing, this does not
+     * look for headings — it chunks by line count with overlap.
+     */
+    indexPlainText(content, source, linesPerChunk = 20) {
+        if (!content || content.trim().length === 0) {
+            const insertSource = this.#db.prepare("INSERT INTO sources (label, chunk_count, code_chunk_count) VALUES (?, 0, 0)");
+            const info = insertSource.run(source);
+            return {
+                sourceId: Number(info.lastInsertRowid),
+                label: source,
+                totalChunks: 0,
+                codeChunks: 0,
+            };
+        }
+        const chunks = this.#chunkPlainText(content, linesPerChunk);
+        const insertSource = this.#db.prepare("INSERT INTO sources (label, chunk_count, code_chunk_count) VALUES (?, ?, ?)");
+        const insertChunk = this.#db.prepare("INSERT INTO chunks (title, content, source_id, content_type) VALUES (?, ?, ?, ?)");
+        const transaction = this.#db.transaction(() => {
+            const info = insertSource.run(source, chunks.length, 0);
+            const sourceId = Number(info.lastInsertRowid);
+            for (const chunk of chunks) {
+                insertChunk.run(chunk.title, chunk.content, sourceId, "prose");
+            }
+            return sourceId;
+        });
+        const sourceId = transaction();
+        return {
+            sourceId,
+            label: source,
+            totalChunks: chunks.length,
+            codeChunks: 0,
+        };
+    }
     // ── Search ──
     search(query, limit = 3) {
         const sanitized = sanitizeQuery(query);
@@ -203,6 +239,41 @@ export class ContentStore {
         flush();
         return chunks;
     }
+    #chunkPlainText(text, linesPerChunk) {
+        // Try blank-line splitting first for naturally-sectioned output
+        const sections = text.split(/\n\s*\n/);
+        if (sections.length >= 3 &&
+            sections.length <= 200 &&
+            sections.every((s) => Buffer.byteLength(s) < 5000)) {
+            return sections
+                .map((section, i) => ({
+                title: `Section ${i + 1}`,
+                content: section.trim(),
+            }))
+                .filter((s) => s.content.length > 0);
+        }
+        const lines = text.split("\n");
+        // Small enough for a single chunk
+        if (lines.length <= linesPerChunk) {
+            return [{ title: "Output", content: text }];
+        }
+        // Fixed-size line groups with 2-line overlap
+        const chunks = [];
+        const overlap = 2;
+        const step = Math.max(linesPerChunk - overlap, 1);
+        for (let i = 0; i < lines.length; i += step) {
+            const slice = lines.slice(i, i + linesPerChunk);
+            if (slice.length === 0)
+                break;
+            const startLine = i + 1;
+            const endLine = Math.min(i + slice.length, lines.length);
+            chunks.push({
+                title: `Lines ${startLine}-${endLine}`,
+                content: slice.join("\n"),
+            });
+        }
+        return chunks;
+    }
     #buildTitle(headingStack, currentHeading) {
         if (headingStack.length === 0) {
             return currentHeading || "Untitled";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "type": "module",
   "description": "Claude Code MCP plugin that saves 94% of your context window. Sandboxed code execution, FTS5 knowledge base, and smart truncation.",
   "author": "Mert Koseoğlu",