@adeu/mcp-server 1.15.1 → 1.16.0

package/src/mcp.bugs.test.ts

@@ -189,6 +189,29 @@ describe("Resolved Bugs MCP Server Verification", () => {
     expect(res.result.content[0].text).toContain("Dry-run simulation complete.");
   });
 
+  it("Unparseable String: process_document_batch gracefully rejects raw strings instead of crashing", async () => {
+    const res = await sendRpc(
+      "tools/call",
+      {
+        name: "process_document_batch",
+        arguments: {
+          original_docx_path: cleanDocPath,
+          author_name: "Agent",
+          changes: [
+            "modify document to be clean document" // Raw unparseable string
+          ],
+          dry_run: false,
+        },
+      },
+      110,
+    );
+
+    expect(res.result.isError).toBe(true);
+    expect(res.result.content[0].text).toContain("Batch rejected. Some edits failed validation");
+    expect(res.result.content[0].text).toContain("Invalid change format");
+    expect(res.result.content[0].text).toContain("received a primitive string");
+  });
+
   it("BUG-12: Accepts stringified numbers for numeric arguments without Zod validation errors", async () => {
     const res = await sendRpc(
       "tools/call",

package/src/mcp.schema-gaps.test.ts

@@ -0,0 +1,384 @@
+// FILE: node/packages/mcp-server/src/mcp.schema-gaps.test.ts
+//
+// Guards the MCP boundary's HONESTY: what the server advertises over `tools/list`
+// (the schema + documentation an LLM sees) must match what the tools really do.
+// Each block below closed a gap where an agent, behaving exactly as documented,
+// was either misled or kept from a capability that exists — "under-documented
+// power is unused power." These tests now assert the corrected state and fail if
+// any gap regresses.
+//
+// Gaps closed:
+//   • process_document_batch — `changes` now publishes a typed item schema so the
+//     six DocumentChange variants are discoverable (ADEU_TOOL_ISSUES #1), and the
+//     real `match_mode`/`regex` options are documented in both schema and prose
+//     (#10). Both are still proven honored at the live boundary.
+//   • read_docx — its description carries the build stamp exactly once (UI tools
+//     were previously double-wrapped and stamped twice).
+//   • diff_docx_files — described as the custom `@@ Word Patch @@` format it
+//     actually emits, no longer mislabeled a "unified diff".
+//   • finalize_document — discloses that `protection_mode:'encrypt'` is unsupported
+//     in the zero-dependency Node build and falls back to a read-only lock.
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { spawn, ChildProcess } from "node:child_process";
+import { resolve, join } from "node:path";
+import { tmpdir } from "node:os";
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { DocumentObject } from "@adeu/core";
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+
+const CHANGE_VARIANTS = [
+  "modify",
+  "accept",
+  "reject",
+  "reply",
+  "insert_row",
+  "delete_row",
+] as const;
+
+const BUILD_STAMP_RE = /\[Adeu v[^\]]*\]/g;
+
+describe("MCP tools — advertised schema/docs match real capability", () => {
+  let serverProc: ChildProcess;
+  let allTools: any[] = [];
+  const tempPaths: string[] = [];
+
+  // Fixtures
+  let pdbFixture: string; // repeated phrase + currency, for match_mode/regex proofs
+  let diffOrig: string;
+  let diffMod: string;
+  let finalizeInput: string;
+
+  const getTool = (name: string) => allTools.find((t) => t.name === name);
+
+  // --- Robust line-buffered JSON-RPC plumbing over stdio ---
+  const pending = new Map<number, (msg: any) => void>();
+  let rpcId = 100;
+  let stdoutBuffer = "";
+
+  function rpc(method: string, params: any): Promise<any> {
+    const id = ++rpcId;
+    return new Promise((resolveRpc, rejectRpc) => {
+      const timeout = setTimeout(
+        () => rejectRpc(new Error(`RPC timeout for ${method}`)),
+        15000,
+      );
+      pending.set(id, (msg) => {
+        clearTimeout(timeout);
+        resolveRpc(msg);
+      });
+      serverProc.stdin?.write(
+        JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n",
+      );
+    });
+  }
+
+  function notify(method: string, params: any): void {
+    serverProc.stdin?.write(
+      JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n",
+    );
+  }
+
+  // Build a docx from a list of paragraph strings (cloning the empty fixture and
+  // clearing its body — `@adeu/core` does not export its test-utils). Tracks the
+  // path for cleanup.
+  async function buildDoc(paragraphs: string[]): Promise<string> {
+    const initialPath = resolve(
+      __dirname,
+      "../../../../shared/fixtures/initial.docx",
+    );
+    const doc = await DocumentObject.load(readFileSync(initialPath));
+    const body = doc.element;
+    while (body.firstChild) body.removeChild(body.firstChild);
+
+    for (const text of paragraphs) {
+      const xmlDoc = body.ownerDocument!;
+      const p = xmlDoc.createElement("w:p");
+      const r = xmlDoc.createElement("w:r");
+      const t = xmlDoc.createElement("w:t");
+      t.textContent = text;
+      if (/\s/.test(text)) t.setAttribute("xml:space", "preserve");
+      r.appendChild(t);
+      p.appendChild(r);
+      body.appendChild(p);
+    }
+
+    const outPath = join(
+      tmpdir(),
+      `adeu_schemagap_${Date.now()}_${tempPaths.length}.docx`,
+    );
+    writeFileSync(outPath, await doc.save());
+    tempPaths.push(outPath);
+    return outPath;
+  }
+
+  function tempOut(label: string): string {
+    const p = join(
+      tmpdir(),
+      `adeu_schemagap_out_${label}_${Date.now()}_${tempPaths.length}.docx`,
+    );
+    tempPaths.push(p);
+    return p;
+  }
+
+  beforeAll(async () => {
+    const serverPath = resolve(__dirname, "../dist/index.js");
+    if (!existsSync(serverPath)) {
+      throw new Error(
+        "MCP server not built. Run 'npm run build' before tests.",
+      );
+    }
+
+    serverProc = spawn("node", [serverPath]);
+    serverProc.stdout?.on("data", (data: Buffer) => {
+      stdoutBuffer += data.toString();
+      let idx: number;
+      while ((idx = stdoutBuffer.indexOf("\n")) !== -1) {
+        const line = stdoutBuffer.slice(0, idx).trim();
+        stdoutBuffer = stdoutBuffer.slice(idx + 1);
+        if (!line.startsWith("{")) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id !== undefined && pending.has(msg.id)) {
+            const cb = pending.get(msg.id)!;
+            pending.delete(msg.id);
+            cb(msg);
+          }
+        } catch {
+          // ignore non-JSON / partial lines
+        }
+      }
+    });
+
+    // Proper MCP handshake, then snapshot the advertised tool list.
+    await rpc("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "schema-gap-test", version: "0.0.0" },
+    });
+    notify("notifications/initialized", {});
+
+    const list = await rpc("tools/list", {});
+    allTools = list.result.tools ?? [];
+
+    pdbFixture = await buildDoc([
+      "The Confidential Information shall remain protected.",
+      "Some unrelated clause about delivery schedules.",
+      "The Confidential Information shall not be disclosed.",
+      "Setup fee is $500 due on signing.",
+    ]);
+    diffOrig = await buildDoc(["The quick brown fox.", "Second clause stays."]);
+    diffMod = await buildDoc([
+      "The slow green turtle.",
+      "Second clause stays.",
+    ]);
+    finalizeInput = await buildDoc(["Some content to finalize."]);
+  });
+
+  afterAll(() => {
+    if (serverProc && !serverProc.killed) serverProc.kill();
+    for (const p of tempPaths) {
+      if (existsSync(p)) {
+        try {
+          unlinkSync(p);
+        } catch {
+          // best-effort cleanup
+        }
+      }
+    }
+  });
+
+  // ======================================================================
+  // process_document_batch — ADEU_TOOL_ISSUES #1: `changes` items are typed
+  // ======================================================================
+  describe("process_document_batch #1: `changes` publishes a typed item schema", () => {
+    it("exposes a `changes.items` schema enumerating all six change variants", () => {
+      const pdbTool = getTool("process_document_batch");
+      expect(
+        pdbTool,
+        "process_document_batch must be advertised",
+      ).toBeDefined();
+
+      const changesProp = pdbTool.inputSchema?.properties?.changes;
+      expect(changesProp?.type).toBe("array");
+
+      const items = changesProp.items;
+      expect(
+        items,
+        "changes.items must describe the change shape",
+      ).toBeTruthy();
+
+      // Every DocumentChange discriminator is now machine-discoverable.
+      const itemsJson = JSON.stringify(items);
+      for (const variant of CHANGE_VARIANTS) {
+        expect(
+          itemsJson,
+          `variant '${variant}' should be discoverable`,
+        ).toContain(variant);
+      }
+    });
+
+    it("exposes the per-variant fields (target_text / new_text / target_id / text), not just prose", () => {
+      const itemsJson = JSON.stringify(
+        getTool("process_document_batch").inputSchema.properties.changes.items,
+      );
+      for (const field of ["target_text", "new_text", "target_id", "text"]) {
+        expect(itemsJson).toContain(field);
+      }
+    });
+  });
+
+  // ======================================================================
+  // process_document_batch — ADEU_TOOL_ISSUES #10: match_mode / regex surfaced
+  // ======================================================================
+  describe("process_document_batch #10: match_mode / regex are documented and honored", () => {
+    it("documents `match_mode` and `regex` in both the schema and the description", () => {
+      const pdbTool = getTool("process_document_batch");
+      const schemaJson = JSON.stringify(pdbTool.inputSchema).toLowerCase();
+      const description: string = (pdbTool.description ?? "").toLowerCase();
+
+      // Discoverable from the schema (the typed change item)...
+      expect(schemaJson).toContain("match_mode");
+      expect(schemaJson).toContain("regex");
+      // ...and called out in the prose guidance too.
+      expect(description).toContain("match_mode");
+      expect(description).toContain("regex");
+    });
+
+    it("honors match_mode:'all' at the live MCP boundary — edits every occurrence (2)", async () => {
+      const res = await rpc("tools/call", {
+        name: "process_document_batch",
+        arguments: {
+          original_docx_path: pdbFixture,
+          author_name: "Schema Gap Test",
+          changes: [
+            {
+              type: "modify",
+              target_text: "The Confidential Information",
+              new_text: "The Proprietary Data",
+              match_mode: "all",
+            },
+          ],
+          dry_run: true,
+        },
+      });
+
+      const text: string = res.result.content[0].text;
+      expect(res.result.isError).toBeFalsy();
+      expect(text).toMatch(/2 occurrences/);
+      expect(text).toContain("`all`");
+    });
+
+    it("honors regex:true (with a capture group) at the live MCP boundary", async () => {
+      const res = await rpc("tools/call", {
+        name: "process_document_batch",
+        arguments: {
+          original_docx_path: pdbFixture,
+          author_name: "Schema Gap Test",
+          changes: [
+            {
+              type: "modify",
+              // A regex, not a literal — `target_text` never appears verbatim in
+              // the doc, so a successful edit proves regex mode was honored.
+              target_text: "\\$(\\d+)",
+              new_text: "USD $1",
+              regex: true,
+            },
+          ],
+          dry_run: true,
+        },
+      });
+
+      const text: string = res.result.content[0].text;
+      expect(res.result.isError).toBeFalsy();
+      expect(text).toContain("USD 500"); // capture group $1 substituted
+    });
+  });
+
+  // ======================================================================
+  // read_docx — build stamp appears exactly once
+  // ======================================================================
+  describe("read_docx: build stamp appears exactly once", () => {
+    it("stamps the build tag once — UI tools are no longer double-wrapped", () => {
+      const readDocx = getTool("read_docx");
+      expect(readDocx, "read_docx must be advertised").toBeDefined();
+
+      const stamps = readDocx.description.match(BUILD_STAMP_RE) ?? [];
+      expect(stamps.length).toBe(1);
+
+      // Parity with a plain (non-UI) tool, which was always stamped once.
+      const pdbStamps =
+        getTool("process_document_batch").description.match(BUILD_STAMP_RE) ??
+        [];
+      expect(pdbStamps.length).toBe(1);
+    });
+  });
+
+  // ======================================================================
+  // diff_docx_files — described as the Word Patch format it actually emits
+  // ======================================================================
+  describe("diff_docx_files: described as the Word Patch format it emits", () => {
+    it("describes its output as a Word Patch, not a 'unified diff'", () => {
+      const desc = getTool("diff_docx_files").description.toLowerCase();
+      expect(desc).not.toContain("unified diff");
+      expect(desc).toContain("word patch");
+    });
+
+    it("emits the custom `@@ Word Patch @@` format at runtime (matching its description)", async () => {
+      const res = await rpc("tools/call", {
+        name: "diff_docx_files",
+        arguments: {
+          original_path: diffOrig,
+          modified_path: diffMod,
+          compare_clean: true,
+        },
+      });
+
+      const text: string = res.result.content[0].text;
+      expect(res.result.isError).toBeFalsy();
+      expect(text).toContain("@@ Word Patch @@");
+      // It is NOT a standard line-based unified diff (no `@@ -l,s +l,s @@` header).
+      expect(text).not.toMatch(/@@ -\d+(,\d+)? \+\d+(,\d+)? @@/);
+    });
+  });
+
+  // ======================================================================
+  // finalize_document — encrypt fallback is disclosed
+  // ======================================================================
+  describe("finalize_document: discloses the encrypt → read-only fallback", () => {
+    it("advertises `encrypt` honestly — dropped from the enum, or its fallback disclosed", () => {
+      const finalizeTool = getTool("finalize_document");
+      const enumVals: string[] =
+        finalizeTool.inputSchema.properties.protection_mode.enum;
+      const desc: string = (finalizeTool.description ?? "").toLowerCase();
+
+      const honest =
+        !enumVals.includes("encrypt") ||
+        (desc.includes("encrypt") &&
+          /read-only|falls back|fallback|unsupported/.test(desc));
+      expect(
+        honest,
+        "encrypt must be dropped from the Node enum or its read-only fallback disclosed",
+      ).toBe(true);
+    });
+
+    it("downgrades encrypt to a read-only lock at runtime, with a warning (matching the disclosure)", async () => {
+      const res = await rpc("tools/call", {
+        name: "finalize_document",
+        arguments: {
+          file_path: finalizeInput,
+          output_path: tempOut("finalize_encrypt"),
+          protection_mode: "encrypt",
+        },
+      });
+
+      const text: string = res.result.content[0].text;
+      expect(res.result.isError).toBeFalsy();
+      expect(text).toContain("Encryption mode");
+      expect(text.toLowerCase()).toContain("unsupported");
+      expect(text).toMatch(/read-only/i);
+    });
+  });
+});

package/src/response-builders.ts

@@ -214,12 +214,11 @@ export function build_search_response(
   search_query: string,
   search_regex: boolean,
   search_case_sensitive: boolean,
-  page: number | string,
+  page: number | string | undefined,
   file_path: string,
 ): ToolResult {
   const [body] = split_structural_appendix(text);
-  const escapeRegExp = (s: string) =>
-    s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const escapeRegExp = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const flags = search_case_sensitive ? "g" : "gi";
   const patternStr = search_regex ? search_query : escapeRegExp(search_query);
 
@@ -230,54 +229,123 @@ export function build_search_response(
     throw new Error(`Invalid regex pattern: ${e.message}`);
   }
 
-  const matches = Array.from(body.matchAll(regex));
+  const allMatches = Array.from(body.matchAll(regex));
 
+  // Compute document pagination once — needed for both annotation and filtering.
+  const pag_res = paginate(body, "");
+  const page_offsets = pag_res.body_page_offsets;
+  const total_doc_pages = pag_res.total_pages;
+
+  // Resolve `page` parameter to either "all" or a concrete document-page number.
+  // Undefined → "all" (search across the whole document).
+  // "all" (case-insensitive) → "all".
+  // A positive integer N → filter matches to document page N.
+  // Anything else → hard error.
+  let filter_doc_page: number | null = null; // null means "all"
+  if (page !== undefined && page !== null) {
+    const pageStr = String(page).toLowerCase();
+    if (pageStr !== "all") {
+      const parsed = parseInt(pageStr, 10);
+      if (isNaN(parsed) || parsed < 1) {
+        throw new Error(
+          `Invalid page value: \`${page}\`. Pass a positive integer to restrict the search to that document page, omit \`page\` to search all pages, or pass \`page='all'\` explicitly.`,
+        );
+      }
+      if (parsed > total_doc_pages) {
+        throw new Error(
+          `Document page ${parsed} is out of range — the document has ${total_doc_pages} page(s). In search mode, \`page\` filters matches to a specific document page; omit it or pass \`page='all'\` to search the whole document.`,
+        );
+      }
+      filter_doc_page = parsed;
+    }
+  }
+
+  // Helper: which document page does an offset live on?
+  const pageOfOffset = (offset: number): number => {
+    let p = 1;
+    for (let j = 0; j < page_offsets.length; j++) {
+      if (offset >= page_offsets[j]) p = j + 1;
+      else break;
+    }
+    return p;
+  };
+
+  // Apply the filter (if any), but keep a record of all pages that had hits
+  // so we can show a useful summary even when filtered.
+  const pagesWithHits = new Set<number>();
+  for (const m of allMatches) {
+    pagesWithHits.add(pageOfOffset(m.index!));
+  }
+
+  const matches =
+    filter_doc_page === null
+      ? allMatches
+      : allMatches.filter((m) => pageOfOffset(m.index!) === filter_doc_page);
+
+  // --- Empty result ---
   if (matches.length === 0) {
-    const ui_markdown = `> **Search Results** — No matches found for query \`${search_query}\` in \`${basename(file_path)}\`.\n\nVerify your search spelling, or try setting \`search_case_sensitive\` to false or enabling \`search_regex\` if you used pattern wildcards.`;
-    const llm_content = `> **File Path:** \`${resolve(file_path)}\`\n\n${ui_markdown}`;
+    let body_msg: string;
+    if (filter_doc_page !== null) {
+      if (allMatches.length === 0) {
+        body_msg = `> **Search Results** — No matches found for query \`${search_query}\` in \`${basename(file_path)}\`.\n\nVerify your search spelling, or try setting \`search_case_sensitive\` to false or enabling \`search_regex\` if you used pattern wildcards.`;
+      } else {
+        const hitPages = Array.from(pagesWithHits).sort((a, b) => a - b);
+        body_msg = `> **Search Results** — No matches for \`${search_query}\` on document page ${filter_doc_page}.\n\nThe query DOES appear elsewhere in the document (${allMatches.length} match${allMatches.length !== 1 ? "es" : ""} on page${hitPages.length !== 1 ? "s" : ""} ${hitPages.join(", ")}). Omit \`page\` or pass \`page='all'\` to see them.`;
+      }
+    } else {
+      body_msg = `> **Search Results** — No matches found for query \`${search_query}\` in \`${basename(file_path)}\`.\n\nVerify your search spelling, or try setting \`search_case_sensitive\` to false or enabling \`search_regex\` if you used pattern wildcards.`;
+    }
+    const llm_content = `> **File Path:** \`${resolve(file_path)}\`\n\n${body_msg}`;
     return {
       content: [{ type: "text", text: llm_content }],
       structuredContent: {
-        markdown: ui_markdown,
+        markdown: body_msg,
         title: `Search: ${basename(file_path)}`,
         file_path: resolve(file_path),
       },
     };
   }
 
-  const pag_res = paginate(body, "");
-  const page_offsets = pag_res.body_page_offsets;
-  const total_matches = matches.length;
-  const total_pages = Math.ceil(total_matches / 10);
-
-  let start_idx = 0;
-  let end_idx = total_matches;
-  let page_text = "all";
-
-  const pageStr = String(page).toLowerCase();
-  if (pageStr !== "all") {
-    const page_num = parseInt(pageStr, 10);
-    if (isNaN(page_num) || page_num < 1 || page_num > total_pages) {
-      throw new Error(`Page ${page} out of range (search has ${total_pages} pages).`);
-    }
-    start_idx = (page_num - 1) * 10;
-    end_idx = Math.min(start_idx + 10, total_matches);
-    page_text = `${page_num} of ${total_pages}`;
-  }
-
-  const page_matches = matches.slice(start_idx, end_idx);
+  // --- Build the response ---
+  const ui_parts: string[] = [];
 
-  const ui_parts: string[] = [
-    `> **Search Results** — Found ${total_matches} matches for query \`${search_query}\` in \`${basename(file_path)}\`.`,
-  ];
-
-  if (total_pages > 1 && pageStr !== "all") {
-    const nextPage = parseInt(pageStr, 10) + 1;
-    ui_parts.push(`> Showing page ${page_text} (matches ${start_idx + 1}-${end_idx}). To see more matches, call \`read_docx\` with \`search_query='${search_query}'\`, \`search_regex=${search_regex ? "true" : "false"}\`, and \`page=${nextPage}\`.`);
+  if (filter_doc_page !== null) {
+    ui_parts.push(
+      `> **Search Results** — Found ${matches.length} match${matches.length !== 1 ? "es" : ""} for \`${search_query}\` on document page ${filter_doc_page} of ${total_doc_pages} in \`${basename(file_path)}\`.`,
+    );
+    const otherPages = Array.from(pagesWithHits)
+      .filter((p) => p !== filter_doc_page)
+      .sort((a, b) => a - b);
+    if (otherPages.length > 0) {
+      ui_parts.push(
+        `> Additional matches exist on page${otherPages.length !== 1 ? "s" : ""} ${otherPages.join(", ")} — omit \`page\` or pass \`page='all'\` to see them.`,
+      );
+    }
+  } else {
+    ui_parts.push(
+      `> **Search Results** — Found ${matches.length} match${matches.length !== 1 ? "es" : ""} for \`${search_query}\` in \`${basename(file_path)}\`.`,
+    );
+    if (total_doc_pages > 1) {
+      // Build a per-page hit distribution: "p1: 3, p3: 1, p7: 12"
+      const counts = new Map<number, number>();
+      for (const m of allMatches) {
+        const p = pageOfOffset(m.index!);
+        counts.set(p, (counts.get(p) || 0) + 1);
+      }
+      const distribution = Array.from(counts.entries())
+        .sort((a, b) => a[0] - b[0])
+        .map(([p, n]) => `p${p}: ${n}`)
+        .join(", ");
+      ui_parts.push(
+        `> Distribution across ${total_doc_pages} document pages — ${distribution}. Pass \`page=N\` to filter to a specific document page.`,
+      );
+    }
   }
 
+  // Per-match occurrence counts use the FULL match set, not the filtered one —
+  // this gives the LLM accurate global counts even when filtering.
   const occurrences_map: Record<string, number> = {};
-  for (const m of matches) {
+  for (const m of allMatches) {
     const matched_str = m[0];
     occurrences_map[matched_str] = (occurrences_map[matched_str] || 0) + 1;
   }
@@ -294,7 +362,10 @@ export function build_search_response(
       if (m) {
         const level = m[1].length;
         if (level < current_level) {
-          let cleanHeading = m[2].replace(/\*\*|__|[*_]/g, "").replace(/\{#[^}]+\}/g, "").trim();
+          let cleanHeading = m[2]
+            .replace(/\*\*|__|[*_]/g, "")
+            .replace(/\{#[^}]+\}/g, "")
+            .trim();
           if (cleanHeading.length > 80) {
             cleanHeading = cleanHeading.substring(0, 80) + "...";
           }
@@ -307,24 +378,19 @@ export function build_search_response(
     return path.join(" > ");
   }
 
-  let i = start_idx + 1;
-  for (const m of page_matches) {
+  let i = 1;
+  for (const m of matches) {
     const matched_str = m[0];
     const m_start = m.index!;
     const m_end = m_start + matched_str.length;
-
-    let p_num = 1;
-    for (let j = 0; j < page_offsets.length; j++) {
-      if (m_start >= page_offsets[j]) {
-        p_num = j + 1;
-      } else {
-        break;
-      }
-    }
+    const p_num = pageOfOffset(m_start);
 
     const snippet_start = Math.max(0, m_start - 100);
     const snippet_end = Math.min(body.length, m_end + 100);
-    const snippet = body.substring(snippet_start, m_start) + `**${matched_str}**` + body.substring(m_end, snippet_end);
+    const snippet =
+      body.substring(snippet_start, m_start) +
+      `**${matched_str}**` +
+      body.substring(m_end, snippet_end);
 
     const snippet_lines = snippet
       .split("\n")
@@ -342,7 +408,9 @@ export function build_search_response(
 
     const count = occurrences_map[matched_str];
     ui_parts.push(snippet_lines);
-    ui_parts.push(`*Occurrences:* This exact phrasing appears ${count} time${count !== 1 ? "s" : ""} in the document.`);
+    ui_parts.push(
+      `*Occurrences:* This exact phrasing appears ${count} time${count !== 1 ? "s" : ""} in the document.`,
+    );
 
     i++;
   }