zigsm 1.4.4 → 1.5.0

package/dist/docs.js

@@ -34,6 +34,10 @@ export async function ensureDocs(zigVersion, updatePolicy = "manual", isMcpMode
                 console.log(`Updating documentation for Zig version: ${zigVersion}`);
             const builtinFunctions = await extractBuiltinFunctions(zigVersion, isMcpMode, true);
             await downloadSourcesTar(zigVersion, isMcpMode, true, docSource);
+            // Pre-download version-matched WASM for remote docs
+            if (docSource === "remote") {
+                await downloadVersionWasm(zigVersion, isMcpMode, true);
+            }
             const dir = path.dirname(metadataPath);
             if (!fs.existsSync(dir)) {
                 fs.mkdirSync(dir, { recursive: true });
@@ -100,6 +104,41 @@ export async function downloadSourcesTar(zigVersion, isMcpMode = false, forceUpd
         console.log(`Downloaded sources.tar to ${sourcesPath}`);
     return uint8Array;
 }
+export async function downloadVersionWasm(zigVersion, isMcpMode = false, forceUpdate = false) {
+    const paths = envPaths("zigsm", { suffix: "" });
+    const versionCacheDir = path.join(paths.cache, zigVersion);
+    const wasmCachePath = path.join(versionCacheDir, "main.wasm");
+    if (fs.existsSync(wasmCachePath) && !forceUpdate) {
+        if (!isMcpMode)
+            console.log(`Using cached main.wasm from ${wasmCachePath}`);
+        return new Uint8Array(fs.readFileSync(wasmCachePath));
+    }
+    const url = `https://ziglang.org/documentation/${zigVersion}/std/main.wasm`;
+    if (!isMcpMode)
+        console.log(`Downloading main.wasm from: ${url}`);
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            if (!isMcpMode)
+                console.log(`Failed to download main.wasm: HTTP ${response.status}`);
+            return null;
+        }
+        const buffer = await response.arrayBuffer();
+        const uint8Array = new Uint8Array(buffer);
+        if (!fs.existsSync(versionCacheDir)) {
+            fs.mkdirSync(versionCacheDir, { recursive: true });
+        }
+        fs.writeFileSync(wasmCachePath, uint8Array);
+        if (!isMcpMode)
+            console.log(`Downloaded main.wasm to ${wasmCachePath}`);
+        return uint8Array;
+    }
+    catch (error) {
+        if (!isMcpMode)
+            console.log(`Failed to download main.wasm: ${error}`);
+        return null;
+    }
+}
 async function downloadSourcesTarPath(zigVersion) {
     const paths = envPaths("zigsm", { suffix: "" });
     const versionCacheDir = path.join(paths.cache, zigVersion);

package/dist/local-std-server.js

@@ -1,6 +1,5 @@
 import * as child_process from "node:child_process";
 import * as fs from "node:fs";
-import * as http from "node:http";
 import * as path from "node:path";
 let activeServer = null;
 function findZigExecutable() {
@@ -105,50 +104,23 @@ export function stopLocalStdServer() {
         activeServer = null;
     }
 }
-export async function fetchFromLocalServer(path) {
+export async function fetchFromLocalServer(urlPath) {
     const server = await startLocalStdServer();
-    const url = `${server.baseUrl}${path}`;
-    return new Promise((resolve, reject) => {
-        http.get(url, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-                data += chunk;
-            });
-            res.on("end", () => {
-                if (res.statusCode === 200) {
-                    resolve(data);
-                }
-                else {
-                    reject(new Error(`HTTP ${res.statusCode}: ${data}`));
-                }
-            });
-        }).on("error", (error) => {
-            reject(error);
-        });
-    });
+    const url = `${server.baseUrl}${urlPath}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    }
+    return await response.text();
 }
 export async function getLocalStdSources() {
     const server = await startLocalStdServer();
     const url = `${server.baseUrl}/sources.tar`;
-    return new Promise((resolve, reject) => {
-        http.get(url, (res) => {
-            const chunks = [];
-            res.on("data", (chunk) => {
-                chunks.push(chunk);
-            });
-            res.on("end", () => {
-                if (res.statusCode === 200) {
-                    const buffer = Buffer.concat(chunks);
-                    resolve(new Uint8Array(buffer));
-                }
-                else {
-                    reject(new Error(`Failed to fetch sources.tar: HTTP ${res.statusCode}`));
-                }
-            });
-        }).on("error", (error) => {
-            reject(error);
-        });
-    });
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch sources.tar: HTTP ${response.status}`);
+    }
+    return new Uint8Array(await response.arrayBuffer());
 }
 process.on("exit", stopLocalStdServer);
 process.on("SIGINT", stopLocalStdServer);

package/dist/mcp.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { downloadSourcesTar, ensureDocs, startViewServer, } from "./docs.js";
+import { downloadSourcesTar, downloadVersionWasm, ensureDocs, startViewServer, } from "./docs.js";
 import { registerAllTools } from "./tools.js";
 function parseArgs(args) {
     const options = {
@@ -102,6 +102,11 @@ async function main() {
     }
     const builtinFunctions = await ensureDocs(options.version, options.updatePolicy, true, options.docSource);
     const stdSources = await downloadSourcesTar(options.version, true, false, options.docSource);
+    // Download version-matched WASM for remote docs (different Zig versions have incompatible AST formats)
+    let versionWasm = null;
+    if (options.docSource === "remote") {
+        versionWasm = await downloadVersionWasm(options.version, true);
+    }
     const mcpServer = new McpServer({
         name: "ZSM",
         description: "Retrieves up-to-date documentation for the Zig programming language standard library and builtin functions.",
@@ -110,6 +115,7 @@ async function main() {
     await registerAllTools(mcpServer, builtinFunctions, stdSources, {
         zigVersion: options.version,
         docSource: options.docSource,
+        versionWasm,
     });
     const transport = new StdioServerTransport();
     await mcpServer.connect(transport);

package/dist/tools.js

@@ -224,7 +224,8 @@ function getStdLibItemTool(wasmPath, stdSources) {
 }
 export async function registerAllTools(mcpServer, builtinFunctions, stdSources, options) {
     const currentDir = path.dirname(fileURLToPath(import.meta.url));
-    const wasmPath = path.join(currentDir, "main.wasm");
+    const bundledWasmPath = path.join(currentDir, "main.wasm");
+    const wasmPath = options.versionWasm ?? bundledWasmPath;
     const listBuiltinFunctionsTool = createListBuiltinFunctionsTool(builtinFunctions);
     mcpServer.registerTool(listBuiltinFunctionsTool.name, listBuiltinFunctionsTool.config, listBuiltinFunctionsTool.handler);
     const getBuiltinFunction = getBuiltinFunctionTool(builtinFunctions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigsm",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "type": "module",
   "bin": {
     "zsm": "dist/mcp.js"