mcp-rustdoc 3.0.0 → 4.0.0

package/README.md

@@ -1,6 +1,6 @@
 # mcp-rustdoc
 
-An MCP server that gives AI assistants deep access to the Rust ecosystem. It scrapes docs.rs (and `doc.rust-lang.org` for `std`/`core`/`alloc`) with surgical DOM extraction (cheerio) and queries the crates.io API, exposing seven tools that cover everything from high-level crate overviews to individual method signatures, feature gates, trait impls, and code examples. Responses are cached in memory (5-minute TTL) to avoid redundant fetches.
+An MCP server that gives AI assistants deep access to the Rust ecosystem. It scrapes docs.rs (and `doc.rust-lang.org` for `std`/`core`/`alloc`) with surgical DOM extraction (cheerio) and queries the crates.io API, exposing nine tools that cover everything from high-level crate overviews to individual method signatures, feature gates, trait impls, and code examples. Responses are cached in memory (5-minute TTL) to avoid redundant fetches.
 
 ## Tools
 
@@ -13,6 +13,8 @@ An MCP server that gives AI assistants deep access to the Rust ecosystem. It scr
 | `lookup_crate_item` | Item detail: signature, docs, methods, variants, optionally trait impls + examples |
 | `search_crate` | Ranked symbol search (exact > prefix > substring) with canonical paths |
 | `search_crates` | Search crates.io by keyword — returns name, description, downloads, version |
+| `get_crate_versions` | All published versions with dates and yanked status (crates.io API) |
+| `get_source_code` | Raw source code of a file from docs.rs or doc.rust-lang.org |
 
 Every tool accepts an optional `version` parameter to pin a specific crate version instead of `latest`.
 
@@ -371,6 +373,52 @@ Search for Rust crates on crates.io by keyword.
 
 ---
 
+### `get_crate_versions`
+
+List all published versions of a crate from crates.io.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `crateName` | string | yes | Crate name |
+
+```
+> get_crate_versions({ crateName: "serde" })
+
+# serde — 312 versions
+
+  1.0.219  2025-02-01
+  1.0.218  2025-01-12
+  1.0.217  2024-12-23
+  ...
+  0.1.0  2014-12-09
+```
+
+---
+
+### `get_source_code`
+
+Fetch the raw source code of a file from docs.rs (or doc.rust-lang.org for std crates).
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `crateName` | string | yes | Crate name |
+| `path` | string | yes | Source path relative to crate root (e.g. `"src/lib.rs"`, `"src/sync/mutex.rs"`) |
+| `version` | string | no | Pinned version |
+
+```
+> get_source_code({ crateName: "tokio", path: "src/sync/mutex.rs" })
+
+# Source: tokio/src/sync/mutex.rs
+https://docs.rs/tokio/latest/src/tokio/sync/mutex.rs
+
+\`\`\`rust
+use crate::sync::batch_semaphore as semaphore;
+...
+\`\`\`
+```
+
+---
+
 ## Recommended workflows
 
 ### Exploring a new crate
@@ -408,6 +456,8 @@ src/
     lookup-item.ts      lookup_crate_item
     search.ts           search_crate
     search-crates.ts    search_crates
+    crate-versions.ts   get_crate_versions
+    source-code.ts      get_source_code
     crate-metadata.ts   get_crate_metadata
     crate-brief.ts      get_crate_brief
 ```

package/dist/index.js

@@ -2,26 +2,51 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import axios from "axios";
 import { load } from "cheerio";
-import { convert } from "html-to-text";
 const DEFAULT_TTL = 5 * 60 * 1e3;
+const STALE_GRACE = 15 * 60 * 1e3;
+const MAX_ENTRIES = 500;
 const store = /* @__PURE__ */ new Map();
 function cacheGet(key) {
   const entry = store.get(key);
   if (!entry) return null;
-  if (Date.now() > entry.expiry) {
+  const now = Date.now();
+  if (now > entry.staleExpiry) {
     store.delete(key);
     return null;
   }
+  entry.lastAccess = now;
   return entry.data;
 }
+function cacheIsStale(key) {
+  const entry = store.get(key);
+  if (!entry) return true;
+  return Date.now() > entry.expiry;
+}
 function cacheSet(key, data, ttl = DEFAULT_TTL) {
-  store.set(key, { data, expiry: Date.now() + ttl });
+  while (store.size >= MAX_ENTRIES) evictLru();
+  const now = Date.now();
+  store.set(key, {
+    data,
+    expiry: now + ttl,
+    staleExpiry: now + STALE_GRACE,
+    lastAccess: now
+  });
+}
+function evictLru() {
+  let oldestKey = null;
+  let oldestAccess = Infinity;
+  for (const [key, entry] of store) {
+    if (entry.lastAccess < oldestAccess) {
+      oldestAccess = entry.lastAccess;
+      oldestKey = key;
+    }
+  }
+  if (oldestKey) store.delete(oldestKey);
 }
 const DOCS_BASE = "https://docs.rs";
 const CRATES_IO = "https://crates.io/api/v1";
-const USER_AGENT = "mcp-rust-docs/3.0.0";
+const USER_AGENT = "mcp-rust-docs/4.0.0";
 const MAX_DOC_LENGTH = 6e3;
 const MAX_SEARCH_RESULTS = 100;
 const SECTION_TO_TYPE = {
@@ -72,24 +97,78 @@ function modToUrlPrefix(modulePath) {
 function modToRustPrefix(modulePath) {
   return modulePath ? modulePath.replace(/\./g, "::") + "::" : "";
 }
+class HttpError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+async function fetchWithRetry(fn, retries = 2, baseDelay = 500) {
+  for (let i = 0; i <= retries; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (i === retries) throw e;
+      const isRetryable = e instanceof HttpError && e.status >= 500;
+      if (!isRetryable) throw e;
+      console.log(`[retry ${i + 1}/${retries}] ${e.message}`);
+      await new Promise((r) => setTimeout(r, baseDelay * (i + 1)));
+    }
+  }
+  throw new Error("unreachable");
+}
+async function fetchText(url, timeout = 15e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetch(url, {
+      headers: { "User-Agent": USER_AGENT },
+      signal: controller.signal
+    });
+    if (!res.ok) throw new HttpError(res.status, `HTTP ${res.status} for ${url}`);
+    return await res.text();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchJson(url, timeout = 1e4) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetch(url, {
+      headers: { "User-Agent": USER_AGENT },
+      signal: controller.signal
+    });
+    if (!res.ok) throw new HttpError(res.status, `HTTP ${res.status} for ${url}`);
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function fetchDom(url) {
-  const cached = cacheGet(`dom:${url}`);
+  const cacheKey = `dom:${url}`;
+  const cached = cacheGet(cacheKey);
   if (cached) {
     console.log(`[cache hit] ${url}`);
+    if (cacheIsStale(cacheKey)) {
+      console.log(`[stale refresh] ${url}`);
+      fetchWithRetry(() => fetchText(url)).then((html2) => cacheSet(cacheKey, html2)).catch(() => {
+      });
+    }
     return load(cached);
   }
-  const { data } = await axios.get(url, { timeout: 15e3 });
-  cacheSet(`dom:${url}`, data);
-  return load(data);
+  const html = await fetchWithRetry(() => fetchText(url));
+  cacheSet(cacheKey, html);
+  return load(html);
 }
 function cleanHtml(html) {
-  return convert(html, {
-    wordwrap: 120,
-    selectors: [
-      { selector: "a", options: { ignoreHref: true } },
-      { selector: "img", format: "skip" }
-    ]
-  }).trim();
+  const $ = load(`<body>${html}</body>`);
+  $("img").remove();
+  $("summary.hideme").remove();
+  $("p, div, br, h1, h2, h3, h4, h5, h6, li, tr").each((_, el) => {
+    $(el).before("\n");
+  });
+  return $("body").text().replace(/\n{3,}/g, "\n\n").trim();
 }
 function truncate(text, max) {
   return text.length > max ? text.slice(0, max) + "\n\n[…truncated]" : text;
@@ -100,7 +179,6 @@ function textResult(text) {
 function errorResult(msg) {
   return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
 }
-const cratesIoHeaders = { "User-Agent": USER_AGENT };
 async function fetchCrateInfo(name) {
   const cacheKey = `crate-info:${name}`;
   const cached = cacheGet(cacheKey);
@@ -108,17 +186,16 @@ async function fetchCrateInfo(name) {
     console.log(`[cache hit] crate-info ${name}`);
     return cached;
   }
-  const { data } = await axios.get(`${CRATES_IO}/crates/${name}`, {
-    headers: cratesIoHeaders,
-    timeout: 1e4
-  });
+  const data = await fetchWithRetry(
+    () => fetchJson(`${CRATES_IO}/crates/${name}`)
+  );
   const c = data.crate;
   const info = {
     name: c.name,
     version: c.max_stable_version || c.max_version,
     description: c.description,
-    documentation: c.documentation,
-    repository: c.repository,
+    documentation: c.documentation ?? null,
+    repository: c.repository ?? null,
     downloads: c.downloads
   };
   cacheSet(cacheKey, info);
@@ -131,10 +208,9 @@ async function fetchCrateVersionInfo(name, version) {
     console.log(`[cache hit] crate-version ${name}@${version}`);
     return cached;
   }
-  const { data } = await axios.get(`${CRATES_IO}/crates/${name}/${version}`, {
-    headers: cratesIoHeaders,
-    timeout: 1e4
-  });
+  const data = await fetchWithRetry(
+    () => fetchJson(`${CRATES_IO}/crates/${name}/${version}`)
+  );
   const v = data.version;
   const features = v.features ?? {};
   const info = {
@@ -142,7 +218,8 @@ async function fetchCrateVersionInfo(name, version) {
     features,
     defaultFeatures: features["default"] ?? [],
     yanked: v.yanked,
-    license: v.license
+    license: v.license,
+    msrv: v.rust_version ?? null
   };
   cacheSet(cacheKey, info);
   return info;
@@ -154,10 +231,9 @@ async function fetchCrateDeps(name, version) {
     console.log(`[cache hit] crate-deps ${name}@${version}`);
     return cached;
   }
-  const { data } = await axios.get(`${CRATES_IO}/crates/${name}/${version}/dependencies`, {
-    headers: cratesIoHeaders,
-    timeout: 1e4
-  });
+  const data = await fetchWithRetry(
+    () => fetchJson(`${CRATES_IO}/crates/${name}/${version}/dependencies`)
+  );
   const deps = (data.dependencies ?? []).map((d) => ({
     name: d.crate_id,
     req: d.req,
@@ -168,6 +244,35 @@ async function fetchCrateDeps(name, version) {
   cacheSet(cacheKey, deps);
   return deps;
 }
+async function searchAllItems(crateName, query, version = "latest") {
+  const url = docsUrl(crateName, "all.html", version);
+  const $ = await fetchDom(url);
+  const q = query.toLowerCase();
+  const results = [];
+  $("h3").each((_, h3) => {
+    const rawId = $(h3).attr("id") ?? "";
+    const type = SECTION_TO_TYPE[rawId] ?? rawId;
+    $(h3).next("ul.all-items").find("li a").each((_2, a) => {
+      const name = $(a).text().trim();
+      const lower = name.toLowerCase();
+      const bareName = name.includes("::") ? name.split("::").pop() : name;
+      const bareNameLower = bareName.toLowerCase();
+      let score = 0;
+      if (bareNameLower === q) score = 100;
+      else if (lower === q) score = 95;
+      else if (bareNameLower.startsWith(q)) score = 60;
+      else if (lower.startsWith(q)) score = 55;
+      else if (lower.includes(q)) score = 20;
+      if (score > 0) {
+        const parts = name.split("::");
+        const modulePath = parts.length > 1 ? parts.slice(0, -1).join(".") : "";
+        results.push({ type, name, path: name, modulePath, bareName, score });
+      }
+    });
+  });
+  results.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  return results;
+}
 function extractItemFeatureGate($) {
   const gate = $(".item-info .stab.portability").first().text().trim();
   return gate || null;
@@ -209,7 +314,7 @@ const itemTypeEnum = z.enum([
   "derive"
 ]);
 const versionParam = z.string().optional().describe('Crate version (e.g. "1.49.0"). Defaults to latest.');
-function register$6(server2) {
+function register$b(server2) {
   server2.tool(
     "lookup_crate_docs",
     "Fetch the main documentation for a Rust crate. Returns overview, version, sections, and re-exports.",
@@ -246,17 +351,18 @@ function register$6(server2) {
     }
   );
 }
-function register$5(server2) {
+function register$a(server2) {
   server2.tool(
     "get_crate_items",
-    "List public items in a crate root or module. Returns names, types, feature gates, and short descriptions.",
+    "List public items in a crate root or module. Returns names, types, feature gates, and short descriptions. Supports filtering by item type and feature gate.",
     {
       crateName: z.string().describe("Crate name"),
       modulePath: z.string().optional().describe('Dot-separated module path (e.g. "sync", "io.util"). Omit for crate root.'),
       itemType: itemTypeEnum.optional().describe("Filter results to a single item type"),
+      feature: z.string().optional().describe('Filter to items gated behind this feature (e.g. "sync", "fs")'),
       version: versionParam
     },
-    async ({ crateName, modulePath, itemType, version }) => {
+    async ({ crateName, modulePath, itemType, feature, version }) => {
       try {
         const ver = version ?? "latest";
         const url = docsUrl(crateName, `${modToUrlPrefix(modulePath)}index.html`, ver);
@@ -272,18 +378,23 @@ function register$5(server2) {
             const desc = $dt.next("dd").text().trim();
             const gate = $dt.find(".stab.portability code").first().text().trim();
             if (!name) return;
+            if (feature) {
+              if (!gate || !gate.toLowerCase().includes(feature.toLowerCase())) return;
+            }
             const tag = gate ? ` [feature: ${gate}]` : "";
             lines.push(`[${type}] ${name}${tag} — ${desc}`);
           });
         });
         const label = modulePath ? `${crateName}::${modulePath.replace(/\./g, "::")}` : crateName;
+        const filters = [];
+        if (itemType) filters.push(`type: ${itemType}`);
+        if (feature) filters.push(`feature: ${feature}`);
+        const filterLabel = filters.length ? ` (${filters.join(", ")})` : "";
         if (!lines.length) {
-          return textResult(
-            `No items found in ${label}${itemType ? ` (type: ${itemType})` : ""}.`
-          );
+          return textResult(`No items found in ${label}${filterLabel}.`);
         }
         return textResult(
-          [`# Items in ${label}${itemType ? ` [${itemType}]` : ""}`, url, "", ...lines].join("\n")
+          [`# Items in ${label}${filterLabel}`, url, "", ...lines].join("\n")
         );
       } catch (e) {
         return errorResult(`Could not list items. ${e.message}`);
@@ -291,15 +402,15 @@ function register$5(server2) {
     }
   );
 }
-function register$4(server2) {
+function register$9(server2) {
   server2.tool(
     "lookup_crate_item",
-    "Get detailed documentation for a specific item. Returns signature, docs, feature gate, methods, trait impls, and optionally examples.",
+    "Get detailed documentation for a specific item. Returns signature, docs, feature gate, methods, trait impls, and optionally examples. Auto-discovers modulePath if omitted.",
     {
       crateName: z.string().describe("Crate name"),
       itemType: itemTypeEnum.describe("Item type"),
       itemName: z.string().describe('Item name (e.g. "Mutex", "spawn", "Serialize")'),
-      modulePath: z.string().optional().describe('Dot-separated module path (e.g. "sync"). Omit if at crate root.'),
+      modulePath: z.string().optional().describe('Dot-separated module path (e.g. "sync"). Auto-discovered if omitted.'),
       version: versionParam,
       includeExamples: z.boolean().optional().describe("Include code examples from the docs. Default: false."),
       includeImpls: z.boolean().optional().describe("Include trait implementation list. Default: false.")
@@ -307,11 +418,46 @@ function register$4(server2) {
     async ({ crateName, itemType, itemName, modulePath, version, includeExamples, includeImpls }) => {
       try {
         const ver = version ?? "latest";
-        const prefix = modToUrlPrefix(modulePath);
+        let resolvedModulePath = modulePath;
+        if (resolvedModulePath === void 0) {
+          const hits = await searchAllItems(crateName, itemName, ver);
+          const match = hits.find(
+            (h) => h.bareName.toLowerCase() === itemName.toLowerCase() && h.type === itemType
+          ) ?? hits.find(
+            (h) => h.bareName.toLowerCase() === itemName.toLowerCase()
+          );
+          if (match) {
+            resolvedModulePath = match.modulePath || void 0;
+            console.log(`[auto-discovery] ${itemName} → ${match.name} (${match.type})`);
+          }
+        }
+        const prefix = modToUrlPrefix(resolvedModulePath);
         const page = itemType === "mod" ? `${prefix}${itemName}/index.html` : `${prefix}${TYPE_FILE_PREFIX[itemType] ?? `${itemType}.`}${itemName}.html`;
         const url = docsUrl(crateName, page, ver);
-        const $ = await fetchDom(url);
-        const fullName = `${crateName}::${modToRustPrefix(modulePath)}${itemName}`;
+        let $;
+        try {
+          $ = await fetchDom(url);
+        } catch (fetchErr) {
+          const hits = await searchAllItems(crateName, itemName, ver);
+          const fuzzy = hits.filter(
+            (h) => h.bareName.toLowerCase().includes(itemName.toLowerCase()) || itemName.toLowerCase().includes(h.bareName.toLowerCase())
+          );
+          if (fuzzy.length) {
+            const suggestions = fuzzy.slice(0, 10).map(
+              (h) => `  [${h.type}] ${crateName}::${h.name}`
+            );
+            return textResult([
+              `Could not find ${itemType} "${itemName}" at the expected path.`,
+              "",
+              "Did you mean one of these?",
+              ...suggestions,
+              "",
+              "Tip: use search_crate to find the exact name and module path."
+            ].join("\n"));
+          }
+          throw fetchErr;
+        }
+        const fullName = `${crateName}::${modToRustPrefix(resolvedModulePath)}${itemName}`;
         const decl = $("pre.rust.item-decl").text().trim();
         const featureGate = extractItemFeatureGate($);
         const doc = truncate(
@@ -389,7 +535,7 @@ function scoreMatch(name, query) {
   if (lower.includes(q)) return 20;
   return 0;
 }
-function register$3(server2) {
+function register$8(server2) {
   server2.tool(
     "search_crate",
     "Search for items by name within a Rust crate. Returns ranked results with canonical paths and item types.",
@@ -433,7 +579,7 @@ function register$3(server2) {
     }
   );
 }
-function register$2(server2) {
+function register$7(server2) {
   server2.tool(
     "get_crate_metadata",
     "Get crate metadata from crates.io: version, features, default features, optional dependencies, and links.",
@@ -467,6 +613,7 @@ Use lookup_crate_docs, get_crate_items, lookup_crate_item, or search_crate to br
         parts.push(`  crates.io: https://crates.io/crates/${info.name}`);
         parts.push(`  license: ${versionInfo.license}`);
         parts.push(`  downloads: ${info.downloads.toLocaleString()}`);
+        if (versionInfo.msrv) parts.push(`  msrv: ${versionInfo.msrv}`);
         const { features, defaultFeatures } = versionInfo;
         parts.push("", "## Features");
         parts.push(`  default = [${defaultFeatures.join(", ")}]`);
@@ -500,7 +647,7 @@ Use lookup_crate_docs, get_crate_items, lookup_crate_item, or search_crate to br
     }
   );
 }
-function register$1(server2) {
+function register$6(server2) {
   server2.tool(
     "get_crate_brief",
     "Bundle call: fetches crate metadata, overview docs, module list, re-exports, and optionally items from focused modules — all in one shot.",
@@ -610,7 +757,7 @@ function register$1(server2) {
     }
   );
 }
-function register(server2) {
+function register$5(server2) {
   server2.tool(
     "search_crates",
     "Search for Rust crates on crates.io by keyword. Returns name, description, downloads, and version.",
@@ -629,11 +776,12 @@ function register(server2) {
           console.log(`[cache hit] search-crates "${query}" page=${page}`);
           return textResult(cached);
         }
-        const { data } = await axios.get(`${CRATES_IO}/crates`, {
-          params: { q: query, per_page: perPage, page },
-          headers: { "User-Agent": USER_AGENT },
-          timeout: 1e4
+        const params = new URLSearchParams({
+          q: query,
+          per_page: String(perPage),
+          page: String(page)
         });
+        const data = await fetchJson(`${CRATES_IO}/crates?${params}`);
         const crates = data.crates ?? [];
         if (!crates.length) {
           return textResult(`No crates found for "${query}".`);
@@ -658,8 +806,288 @@ function register(server2) {
     }
   );
 }
+function register$4(server2) {
+  server2.tool(
+    "get_crate_versions",
+    "List all published versions of a crate from crates.io, with yanked status and release dates.",
+    {
+      crateName: z.string().describe("Crate name")
+    },
+    async ({ crateName }) => {
+      try {
+        if (isStdCrate(crateName)) {
+          return textResult(
+            `"${crateName}" is part of the Rust standard library and is not published on crates.io.
+Its version matches the Rust toolchain version.`
+          );
+        }
+        const cacheKey = `crate-versions:${crateName}`;
+        const cached = cacheGet(cacheKey);
+        if (cached) {
+          console.log(`[cache hit] crate-versions ${crateName}`);
+          return textResult(cached);
+        }
+        const data = await fetchJson(`${CRATES_IO}/crates/${crateName}/versions`);
+        const versions = (data.versions ?? []).map((v) => ({
+          num: v.num,
+          yanked: v.yanked,
+          created_at: v.created_at,
+          license: v.license ?? ""
+        }));
+        if (!versions.length) {
+          return textResult(`No versions found for "${crateName}".`);
+        }
+        const lines = versions.map((v) => {
+          const date = v.created_at.slice(0, 10);
+          const yanked = v.yanked ? " [YANKED]" : "";
+          return `  ${v.num}  ${date}${yanked}`;
+        });
+        const result = [
+          `# ${crateName} — ${versions.length} versions`,
+          "",
+          ...lines
+        ].join("\n");
+        cacheSet(cacheKey, result);
+        return textResult(result);
+      } catch (e) {
+        return errorResult(`Could not fetch versions for "${crateName}". ${e.message}`);
+      }
+    }
+  );
+}
+function register$3(server2) {
+  server2.tool(
+    "get_source_code",
+    "Fetch the source code of a Rust item from docs.rs. Returns the raw source implementation.",
+    {
+      crateName: z.string().describe("Crate name"),
+      path: z.string().describe('Source path relative to crate root (e.g. "src/lib.rs", "src/sync/mutex.rs")'),
+      version: versionParam
+    },
+    async ({ crateName, path, version }) => {
+      try {
+        if (isStdCrate(crateName)) {
+          const url2 = `https://doc.rust-lang.org/stable/src/${crateName}/${path}`;
+          const $2 = await fetchDom(url2);
+          const code2 = $2("#source-code").text().trim() || $2("pre.rust").text().trim();
+          if (!code2) return errorResult(`No source code found at ${url2}`);
+          return textResult([
+            `# Source: ${crateName}/${path}`,
+            url2,
+            "",
+            "```rust",
+            truncate(code2, 12e3),
+            "```"
+          ].join("\n"));
+        }
+        const ver = version ?? "latest";
+        const url = `${DOCS_BASE}/${crateName}/${ver}/src/${crateSlug(crateName)}/${path}`;
+        const $ = await fetchDom(url);
+        const code = $("#source-code").text().trim() || $("pre.rust").text().trim() || $(".src-line-numbers + code").text().trim();
+        if (!code) {
+          return errorResult(`No source code found at ${url}. Check that the path is correct.`);
+        }
+        return textResult([
+          `# Source: ${crateName}/${path}`,
+          url,
+          "",
+          "```rust",
+          truncate(code, 12e3),
+          "```"
+        ].join("\n"));
+      } catch (e) {
+        return errorResult(`Could not fetch source for "${crateName}/${path}". ${e.message}`);
+      }
+    }
+  );
+}
+const querySchema = z.object({
+  itemType: itemTypeEnum.describe("Item type"),
+  itemName: z.string().describe("Item name"),
+  modulePath: z.string().optional().describe("Dot-separated module path")
+});
+function register$2(server2) {
+  server2.tool(
+    "batch_lookup",
+    "Look up multiple items in a single call. Returns a compact summary (signature + short doc) for each item. Saves round-trips when you need several items.",
+    {
+      crateName: z.string().describe("Crate name"),
+      items: z.array(querySchema).min(1).max(20).describe("Items to look up (max 20)"),
+      version: versionParam
+    },
+    async ({ crateName, items, version }) => {
+      const ver = version ?? "latest";
+      const parts = [`# Batch lookup: ${crateName} (${items.length} items)`, ""];
+      const results = await Promise.allSettled(
+        items.map(async ({ itemType, itemName, modulePath }) => {
+          let resolvedModulePath = modulePath;
+          if (resolvedModulePath === void 0) {
+            const hits = await searchAllItems(crateName, itemName, ver);
+            const match = hits.find(
+              (h) => h.bareName.toLowerCase() === itemName.toLowerCase() && h.type === itemType
+            ) ?? hits.find(
+              (h) => h.bareName.toLowerCase() === itemName.toLowerCase()
+            );
+            if (match) resolvedModulePath = match.modulePath || void 0;
+          }
+          const prefix = modToUrlPrefix(resolvedModulePath);
+          const page = itemType === "mod" ? `${prefix}${itemName}/index.html` : `${prefix}${TYPE_FILE_PREFIX[itemType] ?? `${itemType}.`}${itemName}.html`;
+          const url = docsUrl(crateName, page, ver);
+          const $ = await fetchDom(url);
+          const fullName = `${crateName}::${modToRustPrefix(resolvedModulePath)}${itemName}`;
+          const decl = $("pre.rust.item-decl").text().trim();
+          const featureGate = extractItemFeatureGate($);
+          const doc = truncate(
+            cleanHtml($("details.toggle.top-doc").html() ?? ""),
+            500
+          );
+          return { itemType, fullName, decl, featureGate, doc, url };
+        })
+      );
+      for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const { itemType, itemName } = items[i];
+        if (r.status === "fulfilled") {
+          const { fullName, decl, featureGate, doc, url } = r.value;
+          parts.push(`## ${itemType} ${fullName}`, url);
+          if (featureGate) parts.push(`> ${featureGate}`);
+          if (decl) parts.push("```rust", decl, "```");
+          if (doc) parts.push(doc);
+          parts.push("");
+        } else {
+          parts.push(`## ${itemType} ${itemName}`, `  Error: ${r.reason?.message ?? "unknown error"}`, "");
+        }
+      }
+      return textResult(parts.join("\n"));
+    }
+  );
+}
+function extractGhOwnerRepo(url) {
+  const m = url.match(/github\.com\/([^/]+\/[^/]+)/);
+  if (!m) return null;
+  return m[1].replace(/\.git$/, "");
+}
+function register$1(server2) {
+  server2.tool(
+    "get_crate_changelog",
+    "Fetch recent GitHub releases for a crate. Requires the crate to have a GitHub repository link on crates.io.",
+    {
+      crateName: z.string().describe("Crate name"),
+      count: z.number().min(1).max(20).optional().describe("Number of releases to fetch (default 5, max 20)")
+    },
+    async ({ crateName, count: rawCount }) => {
+      const count = rawCount ?? 5;
+      try {
+        if (isStdCrate(crateName)) {
+          return textResult(
+            `"${crateName}" is part of the Rust standard library.
+See https://github.com/rust-lang/rust/blob/master/RELEASES.md for changelogs.`
+          );
+        }
+        const cacheKey = `changelog:${crateName}:${count}`;
+        const cached = cacheGet(cacheKey);
+        if (cached) {
+          console.log(`[cache hit] changelog ${crateName}`);
+          return textResult(cached);
+        }
+        const info = await fetchCrateInfo(crateName);
+        if (!info.repository) {
+          return errorResult(`No repository link found for "${crateName}" on crates.io.`);
+        }
+        const ownerRepo = extractGhOwnerRepo(info.repository);
+        if (!ownerRepo) {
+          return errorResult(`Repository "${info.repository}" is not a GitHub URL.`);
+        }
+        const releases = await fetchJson(
+          `https://api.github.com/repos/${ownerRepo}/releases?per_page=${count}`
+        );
+        if (!releases.length) {
+          return textResult(`No GitHub releases found for ${ownerRepo}.`);
+        }
+        const parts = [
+          `# ${crateName} — recent releases (${ownerRepo})`,
+          ""
+        ];
+        for (const r of releases) {
+          const date = r.published_at?.slice(0, 10) ?? "unknown";
+          const title = r.name || r.tag_name;
+          const body = r.body ? truncate(r.body.trim(), 1e3) : "(no release notes)";
+          parts.push(`## ${title} (${date})`, body, "");
+        }
+        const result = parts.join("\n");
+        cacheSet(cacheKey, result);
+        return textResult(result);
+      } catch (e) {
+        return errorResult(`Could not fetch changelog for "${crateName}". ${e.message}`);
+      }
+    }
+  );
+}
+function register(server2) {
+  server2.tool(
+    "resolve_type",
+    'Resolve a Rust type path (e.g. "tokio::sync::Mutex" or "std::collections::HashMap") to its documentation. Parses the path to determine the crate, module, and item name automatically.',
+    {
+      typePath: z.string().describe('Full Rust type path (e.g. "tokio::sync::Mutex", "std::collections::HashMap")'),
+      version: versionParam
+    },
+    async ({ typePath, version }) => {
+      try {
+        const segments = typePath.split("::").filter(Boolean);
+        if (segments.length < 2) {
+          return errorResult(
+            `Type path "${typePath}" must have at least a crate and item name (e.g. "serde::Serialize").`
+          );
+        }
+        const crateName = segments[0];
+        const itemName = segments[segments.length - 1];
+        const ver = version ?? "latest";
+        const hits = await searchAllItems(crateName, itemName, ver);
+        const exactMatch = hits.find((h) => {
+          const fullPath = h.name.replace(/::/g, "::");
+          const expectedPath = segments.slice(1).join("::");
+          return fullPath === expectedPath && h.bareName === itemName;
+        }) ?? hits.find((h) => h.bareName === itemName);
+        if (!exactMatch) {
+          const suggestions = hits.slice(0, 10).map(
+            (h) => `  [${h.type}] ${crateName}::${h.name}`
+          );
+          const parts2 = [`Could not resolve "${typePath}".`];
+          if (suggestions.length) {
+            parts2.push("", "Similar items found:", ...suggestions);
+          }
+          return textResult(parts2.join("\n"));
+        }
+        const modulePath = exactMatch.modulePath ? exactMatch.modulePath.replace(/\./g, "/") + "/" : "";
+        const prefix = TYPE_FILE_PREFIX[exactMatch.type] ?? `${exactMatch.type}.`;
+        const page = exactMatch.type === "mod" ? `${modulePath}${itemName}/index.html` : `${modulePath}${prefix}${itemName}.html`;
+        const url = docsUrl(crateName, page, ver);
+        const $ = await fetchDom(url);
+        const decl = $("pre.rust.item-decl").text().trim();
+        const featureGate = extractItemFeatureGate($);
+        const doc = truncate(
+          cleanHtml($("details.toggle.top-doc").html() ?? ""),
+          2e3
+        );
+        const fullName = `${crateName}::${exactMatch.name}`;
+        const parts = [`# ${exactMatch.type} ${fullName}`, url, ""];
+        if (featureGate) parts.push(`> ${featureGate}`, "");
+        if (decl) parts.push("```rust", decl, "```", "");
+        if (doc) parts.push(doc);
+        return textResult(parts.join("\n"));
+      } catch (e) {
+        return errorResult(`Could not resolve "${typePath}". ${e.message}`);
+      }
+    }
+  );
+}
 console.log = (...args) => console.error(...args);
-const server = new McpServer({ name: "rust-docs", version: "3.0.0" });
+const server = new McpServer({ name: "rust-docs", version: "4.0.0" });
+register$b(server);
+register$a(server);
+register$9(server);
+register$8(server);
+register$7(server);
 register$6(server);
 register$5(server);
 register$4(server);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-rustdoc",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "type": "module",
   "description": "MCP server for fetching and browsing Rust crate documentation from docs.rs and crates.io",
   "main": "dist/index.js",
@@ -43,9 +43,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.26.0",
-    "axios": "1.13.4",
     "cheerio": "1.2.0",
-    "html-to-text": "9.0.5",
     "zod": "4.3.6"
   },
   "devDependencies": {