context-mode 1.0.24 → 1.0.27

package/build/cli.js

@@ -14,7 +14,7 @@
 import * as p from "@clack/prompts";
 import color from "picocolors";
 import { execSync } from "node:child_process";
-import { readFileSync, cpSync, accessSync, existsSync, readdirSync, rmSync, closeSync, openSync, constants } from "node:fs";
+import { readFileSync, writeFileSync, cpSync, accessSync, existsSync, readdirSync, rmSync, closeSync, openSync, constants } from "node:fs";
 import { request as httpsRequest } from "node:https";
 import { resolve, dirname, join } from "node:path";
 import { tmpdir, devNull } from "node:os";
@@ -50,6 +50,10 @@ const HOOK_MAP = {
         posttooluse: "hooks/cursor/posttooluse.mjs",
         sessionstart: "hooks/cursor/sessionstart.mjs",
     },
+    "kiro": {
+        pretooluse: "hooks/kiro/pretooluse.mjs",
+        posttooluse: "hooks/kiro/posttooluse.mjs",
+    },
 };
 async function hookDispatch(platform, event) {
     // Suppress stderr at OS fd level — native C++ modules (better-sqlite3) write
@@ -252,21 +256,21 @@ async function doctor() {
         p.log.warn(color.yellow("Plugin enabled: WARN") +
             ` — ${pluginCheck.message}`);
     }
-    // FTS5 / better-sqlite3
-    p.log.step("Checking FTS5 / better-sqlite3...");
+    // FTS5 / SQLite
+    p.log.step("Checking FTS5 / SQLite...");
     try {
-        const Database = (await import("better-sqlite3")).default;
+        const Database = (await import("./db-base.js")).loadDatabase();
         const db = new Database(":memory:");
         db.exec("CREATE VIRTUAL TABLE fts_test USING fts5(content)");
         db.exec("INSERT INTO fts_test(content) VALUES ('hello world')");
         const row = db.prepare("SELECT * FROM fts_test WHERE fts_test MATCH 'hello'").get();
         db.close();
         if (row && row.content === "hello world") {
-            p.log.success(color.green("FTS5 / better-sqlite3: PASS") + " — native module works");
+            p.log.success(color.green("FTS5 / SQLite: PASS") + " — native module works");
         }
         else {
             criticalFails++;
-            p.log.error(color.red("FTS5 / better-sqlite3: FAIL") + " — query returned unexpected result");
+            p.log.error(color.red("FTS5 / SQLite: FAIL") + " — query returned unexpected result");
         }
     }
     catch (err) {
@@ -393,7 +397,7 @@ async function upgrade() {
         }
         const items = [
             "build", "src", "hooks", "skills", ".claude-plugin",
-            "start.mjs", "server.bundle.mjs", "cli.bundle.mjs", "package.json", ".mcp.json",
+            "start.mjs", "server.bundle.mjs", "cli.bundle.mjs", "package.json",
         ];
         for (const item of items) {
             try {
@@ -402,6 +406,16 @@ async function upgrade() {
             }
             catch { /* some files may not exist in source */ }
         }
+        // Write .mcp.json with resolved absolute path (fixes #132)
+        const mcpConfig = {
+            mcpServers: {
+                "context-mode": {
+                    command: "node",
+                    args: [resolve(pluginRoot, "start.mjs")],
+                },
+            },
+        };
+        writeFileSync(resolve(pluginRoot, ".mcp.json"), JSON.stringify(mcpConfig, null, 2) + "\n");
         s.stop(color.green(`Updated in-place to v${newVersion}`));
         // Fix registry — adapter-aware
         adapter.updatePluginRegistry(pluginRoot, newVersion);
@@ -414,6 +428,24 @@ async function upgrade() {
             timeout: 60000,
         });
         s.stop("Dependencies ready");
+        // Rebuild native addons for current Node.js ABI (fixes #131)
+        s.start("Rebuilding native addons");
+        try {
+            execSync("npm rebuild better-sqlite3", {
+                cwd: pluginRoot,
+                stdio: "pipe",
+                timeout: 60000,
+            });
+            s.stop(color.green("Native addons rebuilt"));
+            changes.push("Rebuilt better-sqlite3 for current Node.js");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            s.stop(color.yellow("Native addon rebuild warning"));
+            p.log.warn(color.yellow("better-sqlite3 rebuild issue") +
+                ` — ${message}` +
+                color.dim(`\n  Try manually: cd "${pluginRoot}" && npm rebuild better-sqlite3`));
+        }
         // Update global npm
         s.start("Updating npm global package");
         try {

package/build/db-base.d.ts

@@ -22,9 +22,21 @@ export interface PreparedStatement {
     iterate(...params: unknown[]): IterableIterator<unknown>;
 }
 /**
- * Lazy-load better-sqlite3. Only resolves the native module on first call.
- * This allows the MCP server to start instantly even when the native addon
- * is not yet installed (marketplace first-run scenario).
+ * Wraps a bun:sqlite Database to provide better-sqlite3-compatible API.
+ * Bridges: .pragma(), multi-statement .exec(), .get() null→undefined.
+ */
+export declare class BunSQLiteAdapter {
+    #private;
+    constructor(rawDb: any);
+    pragma(source: string): any;
+    exec(sql: string): any;
+    prepare(sql: string): any;
+    transaction(fn: (...args: any[]) => any): any;
+    close(): void;
+}
+/**
+ * Lazy-load better-sqlite3. Falls back to bun:sqlite via BunSQLiteAdapter
+ * when better-sqlite3 is unavailable (Bun runtime, issue #45).
  */
 export declare function loadDatabase(): typeof DatabaseConstructor;
 /**

package/build/db-base.js

@@ -10,18 +10,110 @@ import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 // ─────────────────────────────────────────────────────────
+// bun:sqlite adapter (#45)
+// ─────────────────────────────────────────────────────────
+/**
+ * Wraps a bun:sqlite Database to provide better-sqlite3-compatible API.
+ * Bridges: .pragma(), multi-statement .exec(), .get() null→undefined.
+ */
+export class BunSQLiteAdapter {
+    #raw;
+    constructor(rawDb) {
+        this.#raw = rawDb;
+    }
+    pragma(source) {
+        const stmt = this.#raw.prepare(`PRAGMA ${source}`);
+        const rows = stmt.all();
+        if (!rows || rows.length === 0)
+            return undefined;
+        // Multi-row pragmas (table_xinfo, etc.) → return array
+        if (rows.length > 1)
+            return rows;
+        // Single-row: extract scalar value (e.g. journal_mode = "wal")
+        const values = Object.values(rows[0]);
+        return values.length === 1 ? values[0] : rows[0];
+    }
+    exec(sql) {
+        // bun:sqlite .exec() is single-statement only.
+        // Split multi-statement SQL respecting string literals (don't split on ; inside quotes).
+        let current = "";
+        let inString = null;
+        for (let i = 0; i < sql.length; i++) {
+            const ch = sql[i];
+            if (inString) {
+                current += ch;
+                if (ch === inString)
+                    inString = null;
+            }
+            else if (ch === "'" || ch === '"') {
+                current += ch;
+                inString = ch;
+            }
+            else if (ch === ";") {
+                const trimmed = current.trim();
+                if (trimmed)
+                    this.#raw.prepare(trimmed).run();
+                current = "";
+            }
+            else {
+                current += ch;
+            }
+        }
+        const trimmed = current.trim();
+        if (trimmed)
+            this.#raw.prepare(trimmed).run();
+        return this;
+    }
+    prepare(sql) {
+        const stmt = this.#raw.prepare(sql);
+        return {
+            run: (...args) => stmt.run(...args),
+            get: (...args) => {
+                const r = stmt.get(...args);
+                return r === null ? undefined : r;
+            },
+            all: (...args) => stmt.all(...args),
+            iterate: (...args) => stmt.iterate(...args),
+        };
+    }
+    transaction(fn) {
+        return this.#raw.transaction(fn);
+    }
+    close() {
+        this.#raw.close();
+    }
+}
+// ─────────────────────────────────────────────────────────
 // Lazy loader
 // ─────────────────────────────────────────────────────────
 let _Database = null;
 /**
- * Lazy-load better-sqlite3. Only resolves the native module on first call.
- * This allows the MCP server to start instantly even when the native addon
- * is not yet installed (marketplace first-run scenario).
+ * Lazy-load better-sqlite3. Falls back to bun:sqlite via BunSQLiteAdapter
+ * when better-sqlite3 is unavailable (Bun runtime, issue #45).
  */
 export function loadDatabase() {
     if (!_Database) {
         const require = createRequire(import.meta.url);
-        _Database = require("better-sqlite3");
+        try {
+            _Database = require("better-sqlite3");
+        }
+        catch {
+            // better-sqlite3 unavailable (Bun runtime) — wrap bun:sqlite
+            if (!globalThis.Bun) {
+                throw new Error("better-sqlite3 failed to load and Bun runtime not detected");
+            }
+            // Compute module name at runtime to prevent esbuild from resolving at bundle time.
+            // esbuild constant-folds string concat but NOT Array.join().
+            const bunSqliteMod = ["bun", "sqlite"].join(":");
+            const BunDB = require(bunSqliteMod).Database;
+            _Database = function BunDatabaseFactory(path, opts) {
+                const raw = new BunDB(path, {
+                    readonly: opts?.readonly,
+                    create: true,
+                });
+                return new BunSQLiteAdapter(raw);
+            };
+        }
     }
     return _Database;
 }

package/build/pi-extension.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pi coding agent extension for context-mode.
+ *
+ * Follows the OpenClaw adapter pattern: imports shared session modules,
+ * registers Pi-specific hooks. NO copy-paste of session logic.
+ * NO external npm dependencies beyond what Pi runtime provides.
+ *
+ * Entry point: `export default function(pi: ExtensionAPI) { ... }`
+ *
+ * Lifecycle: session_start, tool_call, tool_result, before_agent_start,
+ * session_before_compact, session_compact, session_shutdown.
+ */
+/** Pi extension default export. Called once by Pi runtime with the extension API. */
+export default function piExtension(pi: any): void;

package/build/pi-extension.js

@@ -0,0 +1,340 @@
+/**
+ * Pi coding agent extension for context-mode.
+ *
+ * Follows the OpenClaw adapter pattern: imports shared session modules,
+ * registers Pi-specific hooks. NO copy-paste of session logic.
+ * NO external npm dependencies beyond what Pi runtime provides.
+ *
+ * Entry point: `export default function(pi: ExtensionAPI) { ... }`
+ *
+ * Lifecycle: session_start, tool_call, tool_result, before_agent_start,
+ * session_before_compact, session_compact, session_shutdown.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SessionDB } from "./session/db.js";
+import { extractEvents, extractUserEvents } from "./session/extract.js";
+import { buildResumeSnapshot } from "./session/snapshot.js";
+// ── Pi Tool Name Mapping ─────────────────────────────────
+// Pi uses lowercase; shared extractors expect PascalCase (Claude Code convention).
+const PI_TOOL_MAP = {
+    bash: "Bash",
+    read: "Read",
+    write: "Write",
+    edit: "Edit",
+    grep: "Grep",
+    find: "Glob",
+    ls: "Glob",
+};
+// ── Routing patterns ─────────────────────────────────────
+// Inline HTTP client patterns to block in bash — self-contained, no routing module needed.
+const BLOCKED_BASH_PATTERNS = [
+    /\bcurl\s/,
+    /\bwget\s/,
+    /\bfetch\s*\(/,
+    /\brequests\.get\s*\(/,
+    /\brequests\.post\s*\(/,
+    /\bhttp\.get\s*\(/,
+    /\bhttp\.request\s*\(/,
+    /\burllib\.request/,
+    /\bInvoke-WebRequest\b/,
+];
+// ── Module-level DB singleton ────────────────────────────
+let _db = null;
+let _sessionId = "";
+// ── Helpers ──────────────────────────────────────────────
+function getSessionDir() {
+    const dir = join(homedir(), ".pi", "context-mode", "sessions");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function getDBPath() {
+    return join(getSessionDir(), "context-mode.db");
+}
+function getOrCreateDB() {
+    if (!_db) {
+        _db = new SessionDB({ dbPath: getDBPath() });
+    }
+    return _db;
+}
+/** Derive a stable session ID from Pi's session file path (SHA256, 16 hex chars). */
+function deriveSessionId(ctx) {
+    try {
+        const sessionManager = ctx.sessionManager;
+        const sessionFile = sessionManager?.getSessionFile?.();
+        if (sessionFile && typeof sessionFile === "string") {
+            return createHash("sha256").update(sessionFile).digest("hex").slice(0, 16);
+        }
+    }
+    catch {
+        // best effort
+    }
+    return `pi-${Date.now()}`;
+}
+/** Build stats text for the /ctx-stats command. */
+function buildStatsText(db, sessionId) {
+    try {
+        const events = db.getEvents(sessionId);
+        const stats = db.getSessionStats(sessionId);
+        const lines = [
+            "## context-mode stats (Pi)",
+            "",
+            `- Session: \`${sessionId.slice(0, 8)}...\``,
+            `- Events captured: ${events.length}`,
+            `- Compactions: ${stats?.compact_count ?? 0}`,
+        ];
+        // Event breakdown by category
+        const byCategory = {};
+        for (const ev of events) {
+            const key = ev.category ?? "unknown";
+            byCategory[key] = (byCategory[key] ?? 0) + 1;
+        }
+        if (Object.keys(byCategory).length > 0) {
+            lines.push("- Event breakdown:");
+            for (const [category, count] of Object.entries(byCategory)) {
+                lines.push(`  - ${category}: ${count}`);
+            }
+        }
+        // Session age
+        if (stats?.started_at) {
+            const startedMs = new Date(stats.started_at).getTime();
+            const ageMinutes = Math.round((Date.now() - startedMs) / 60_000);
+            lines.push(`- Session age: ${ageMinutes}m`);
+        }
+        return lines.join("\n");
+    }
+    catch {
+        return "context-mode stats unavailable (session DB error)";
+    }
+}
+// ── Extension entry point ────────────────────────────────
+/** Pi extension default export. Called once by Pi runtime with the extension API. */
+export default function piExtension(pi) {
+    const buildDir = dirname(fileURLToPath(import.meta.url));
+    const pluginRoot = resolve(buildDir, "..");
+    const projectDir = process.env.PI_PROJECT_DIR || process.cwd();
+    const db = getOrCreateDB();
+    // ── 1. session_start — Initialize session ──────────────
+    pi.on("session_start", (ctx) => {
+        try {
+            _sessionId = deriveSessionId(ctx ?? {});
+            db.ensureSession(_sessionId, projectDir);
+            db.cleanupOldSessions(7);
+        }
+        catch {
+            // best effort — never break session start
+            if (!_sessionId) {
+                _sessionId = `pi-${Date.now()}`;
+            }
+        }
+    });
+    // ── 2. tool_call — PreToolUse routing enforcement ──────
+    // Block bash commands that contain curl/wget/fetch/requests patterns.
+    pi.on("tool_call", (event) => {
+        try {
+            const toolName = String(event?.toolName ?? "").toLowerCase();
+            if (toolName !== "bash")
+                return;
+            const command = String(event?.input?.command ?? "");
+            if (!command)
+                return;
+            const isBlocked = BLOCKED_BASH_PATTERNS.some((p) => p.test(command));
+            if (isBlocked) {
+                return {
+                    block: true,
+                    reason: "Use context-mode MCP tools (execute, fetch_and_index) instead of inline HTTP clients. " +
+                        "Raw curl/wget/fetch output floods the context window.",
+                };
+            }
+        }
+        catch {
+            // Routing failure — allow passthrough
+        }
+    });
+    // ── 3. tool_result — PostToolUse event capture ─────────
+    pi.on("tool_result", (event) => {
+        try {
+            if (!_sessionId)
+                return;
+            const rawToolName = String(event?.toolName ?? event?.tool_name ?? "");
+            const mappedToolName = PI_TOOL_MAP[rawToolName.toLowerCase()] ?? rawToolName;
+            // Normalize result to string
+            const rawResult = event?.result ?? event?.output;
+            const resultStr = typeof rawResult === "string"
+                ? rawResult
+                : rawResult != null
+                    ? JSON.stringify(rawResult)
+                    : undefined;
+            // Detect errors
+            const hasError = Boolean(event?.error || event?.isError);
+            const hookInput = {
+                tool_name: mappedToolName,
+                tool_input: event?.params ?? event?.input ?? {},
+                tool_response: resultStr,
+                tool_output: hasError ? { isError: true } : undefined,
+            };
+            const events = extractEvents(hookInput);
+            if (events.length > 0) {
+                for (const ev of events) {
+                    db.insertEvent(_sessionId, ev, "PostToolUse");
+                }
+            }
+            else if (rawToolName) {
+                // Fallback: record unrecognized tool call as generic event
+                const data = JSON.stringify({
+                    tool: rawToolName,
+                    params: event?.params ?? event?.input,
+                });
+                db.insertEvent(_sessionId, {
+                    type: "tool_call",
+                    category: "pi",
+                    data,
+                    priority: 1,
+                    data_hash: createHash("sha256")
+                        .update(data)
+                        .digest("hex")
+                        .slice(0, 16),
+                }, "PostToolUse");
+            }
+        }
+        catch {
+            // Silent — session capture must never break the tool call
+        }
+    });
+    // ── 4. before_agent_start — Resume injection + user events ─
+    pi.on("before_agent_start", (event) => {
+        try {
+            if (!_sessionId)
+                return;
+            const prompt = String(event?.prompt ?? "");
+            // Extract user events from the prompt text
+            if (prompt) {
+                const userEvents = extractUserEvents(prompt);
+                for (const ev of userEvents) {
+                    db.insertEvent(_sessionId, ev, "UserPromptSubmit");
+                }
+            }
+            // Check for unconsumed resume snapshot
+            const resume = db.getResume(_sessionId);
+            if (!resume || resume.consumed)
+                return;
+            // Build FTS5 active memory from the current prompt
+            const stats = db.getSessionStats(_sessionId);
+            if ((stats?.compact_count ?? 0) === 0)
+                return;
+            // Mark resume as consumed so it is not re-injected
+            db.markResumeConsumed(_sessionId);
+            // Build memory context from recent high-priority events
+            const allEvents = db.getEvents(_sessionId, { minPriority: 2, limit: 50 });
+            let memoryContext = "";
+            if (allEvents.length > 0) {
+                const memoryLines = ["<active_memory>"];
+                for (const ev of allEvents) {
+                    memoryLines.push(`  <event type="${ev.type}" category="${ev.category}">${ev.data}</event>`);
+                }
+                memoryLines.push("</active_memory>");
+                memoryContext = memoryLines.join("\n");
+            }
+            // Compose the augmented system prompt
+            const existingPrompt = String(event?.systemPrompt ?? "");
+            const parts = [];
+            if (existingPrompt)
+                parts.push(existingPrompt);
+            if (resume.snapshot)
+                parts.push(resume.snapshot);
+            if (memoryContext)
+                parts.push(memoryContext);
+            if (parts.length > (existingPrompt ? 1 : 0)) {
+                return { systemPrompt: parts.join("\n\n") };
+            }
+        }
+        catch {
+            // best effort — never break agent start
+        }
+    });
+    // ── 5. session_before_compact — Build resume snapshot ──
+    pi.on("session_before_compact", () => {
+        try {
+            if (!_sessionId)
+                return;
+            const allEvents = db.getEvents(_sessionId);
+            if (allEvents.length === 0)
+                return;
+            const stats = db.getSessionStats(_sessionId);
+            const snapshot = buildResumeSnapshot(allEvents, {
+                compactCount: (stats?.compact_count ?? 0) + 1,
+            });
+            db.upsertResume(_sessionId, snapshot, allEvents.length);
+        }
+        catch {
+            // best effort — never break compaction
+        }
+    });
+    // ── 6. session_compact — Increment compact counter ─────
+    pi.on("session_compact", () => {
+        try {
+            if (!_sessionId)
+                return;
+            db.incrementCompactCount(_sessionId);
+        }
+        catch {
+            // best effort
+        }
+    });
+    // ── 7. session_shutdown — Cleanup old sessions ─────────
+    pi.on("session_shutdown", () => {
+        try {
+            if (_db) {
+                _db.cleanupOldSessions(7);
+            }
+            _db = null;
+            _sessionId = "";
+        }
+        catch {
+            // best effort — never throw during shutdown
+        }
+    });
+    // ── 8. Slash commands ──────────────────────────────────
+    pi.registerCommand("ctx-stats", {
+        description: "Show context-mode session statistics",
+        handler: () => {
+            if (!_db || !_sessionId) {
+                return { text: "context-mode: no active session" };
+            }
+            return { text: buildStatsText(_db, _sessionId) };
+        },
+    });
+    pi.registerCommand("ctx-doctor", {
+        description: "Run context-mode diagnostics",
+        handler: () => {
+            const dbPath = getDBPath();
+            const dbExists = existsSync(dbPath);
+            const lines = [
+                "## ctx-doctor (Pi)",
+                "",
+                `- DB path: \`${dbPath}\``,
+                `- DB exists: ${dbExists}`,
+                `- Session ID: \`${_sessionId ? _sessionId.slice(0, 8) + "..." : "none"}\``,
+                `- Plugin root: \`${pluginRoot}\``,
+                `- Project dir: \`${projectDir}\``,
+            ];
+            if (_db && _sessionId) {
+                try {
+                    const stats = _db.getSessionStats(_sessionId);
+                    const eventCount = _db.getEventCount(_sessionId);
+                    lines.push(`- Events: ${eventCount}`);
+                    lines.push(`- Compactions: ${stats?.compact_count ?? 0}`);
+                    const resume = _db.getResume(_sessionId);
+                    lines.push(`- Resume snapshot: ${resume ? (resume.consumed ? "consumed" : "available") : "none"}`);
+                }
+                catch {
+                    lines.push("- DB query error");
+                }
+            }
+            return { text: lines.join("\n") };
+        },
+    });
+}

package/build/server.js

@@ -15,6 +15,7 @@ import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime
 import { classifyNonZeroExit } from "./exit-classify.js";
 import { startLifecycleGuard } from "./lifecycle.js";
 import { getWorktreeSuffix } from "./session/db.js";
+import { loadDatabase } from "./db-base.js";
 const __pkg_dir = dirname(fileURLToPath(import.meta.url));
 const VERSION = (() => {
     for (const rel of ["../package.json", "./package.json"]) {
@@ -789,6 +790,10 @@ server.registerTool("ctx_search", {
             .string()
             .optional()
             .describe("Filter to a specific indexed source (partial match)."),
+        contentType: z
+            .enum(["code", "prose"])
+            .optional()
+            .describe("Filter results by content type: 'code' or 'prose'."),
     }),
 }, async (params) => {
     try {
@@ -808,7 +813,7 @@ server.registerTool("ctx_search", {
                 isError: true,
             });
         }
-        const { limit = 3, source } = params;
+        const { limit = 3, source, contentType } = params;
         // Progressive throttling: track calls in time window
         const now = Date.now();
         if (now - searchWindowStart > SEARCH_WINDOW_MS) {
@@ -840,7 +845,7 @@ server.registerTool("ctx_search", {
                 sections.push(`## ${q}\n(output cap reached)\n`);
                 continue;
             }
-            const results = store.searchWithFallback(q, effectiveLimit, source);
+            const results = store.searchWithFallback(q, effectiveLimit, source, contentType);
             if (results.length === 0) {
                 sections.push(`## ${q}\nNo results found.`);
                 continue;
@@ -1314,8 +1319,7 @@ server.registerTool("ctx_stats", {
         const worktreeSuffix = getWorktreeSuffix();
         const sessionDbPath = join(homedir(), ".claude", "context-mode", "sessions", `${dbHash}${worktreeSuffix}.db`);
         if (existsSync(sessionDbPath)) {
-            const require = createRequire(import.meta.url);
-            const Database = require("better-sqlite3");
+            const Database = loadDatabase();
             const sdb = new Database(sessionDbPath, { readonly: true });
             const eventTotal = sdb.prepare("SELECT COUNT(*) as cnt FROM session_events").get();
             const byCategory = sdb.prepare("SELECT category, COUNT(*) as cnt FROM session_events GROUP BY category ORDER BY cnt DESC").all();

package/build/store.d.ts

@@ -37,10 +37,10 @@ export declare class ContentStore {
      * Falls back to `indexPlainText` if the content is not valid JSON.
      */
     indexJSON(content: string, source: string, maxChunkBytes?: number): IndexResult;
-    search(query: string, limit?: number, source?: string, mode?: "AND" | "OR"): SearchResult[];
-    searchTrigram(query: string, limit?: number, source?: string, mode?: "AND" | "OR"): SearchResult[];
+    search(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose"): SearchResult[];
+    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): SearchResult[];
+    searchWithFallback(query: string, limit?: number, source?: string, contentType?: "code" | "prose"): SearchResult[];
     listSources(): Array<{
         label: string;
         chunkCount: number;