zigsm 1.4.0

package/dist/local-std-server.js

@@ -0,0 +1,155 @@
+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() {
+    const zigPath = process.env.ZIG_PATH || "zig";
+    try {
+        const result = child_process.execSync(`${zigPath} version`, { encoding: "utf8" });
+        if (result.includes("dev") || /\d+\.\d+\.\d+/.test(result)) {
+            return zigPath;
+        }
+    }
+    catch {
+        // Continue to fallback
+    }
+    const commonPaths = [
+        "/usr/local/bin/zig",
+        "/usr/bin/zig",
+        "/opt/homebrew/bin/zig",
+        "/opt/zig/zig",
+        path.join(process.env.HOME || "", ".local/bin/zig"),
+    ];
+    for (const p of commonPaths) {
+        if (fs.existsSync(p)) {
+            try {
+                child_process.execSync(`${p} version`, { encoding: "utf8" });
+                return p;
+            }
+            catch {
+                // Continue checking
+            }
+        }
+    }
+    return "zig";
+}
+export function getZigVersion() {
+    const zigPath = findZigExecutable();
+    try {
+        const result = child_process.execSync(`${zigPath} version`, { encoding: "utf8" });
+        return result.trim();
+    }
+    catch (error) {
+        throw new Error(`Failed to get Zig version: ${error}`);
+    }
+}
+export async function startLocalStdServer() {
+    if (activeServer) {
+        return activeServer;
+    }
+    const zigPath = findZigExecutable();
+    return new Promise((resolve, reject) => {
+        const stdProcess = child_process.spawn(zigPath, ["std", "--no-open-browser"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let output = "";
+        let errorOutput = "";
+        let resolved = false;
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                stdProcess.kill();
+                reject(new Error("Timeout waiting for Zig std server to start"));
+            }
+        }, 10000);
+        stdProcess.stdout?.on("data", (data) => {
+            output += data.toString();
+            // Match patterns like "http://127.0.0.1:43695/"
+            const match = output.match(/(http:\/\/[0-9.]+:[0-9]+)/);
+            if (match && !resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                const baseUrl = match[1];
+                const port = parseInt(baseUrl.split(":").pop() || "43695");
+                activeServer = {
+                    process: stdProcess,
+                    port,
+                    baseUrl,
+                };
+                resolve(activeServer);
+            }
+        });
+        stdProcess.stderr?.on("data", (data) => {
+            errorOutput += data.toString();
+        });
+        stdProcess.on("error", (error) => {
+            clearTimeout(timeout);
+            if (!resolved) {
+                resolved = true;
+                reject(new Error(`Failed to start Zig std server: ${error.message}`));
+            }
+        });
+        stdProcess.on("exit", (code) => {
+            clearTimeout(timeout);
+            if (!resolved) {
+                resolved = true;
+                reject(new Error(`Zig std server exited with code ${code}: ${errorOutput}`));
+            }
+            activeServer = null;
+        });
+    });
+}
+export function stopLocalStdServer() {
+    if (activeServer) {
+        activeServer.process.kill();
+        activeServer = null;
+    }
+}
+export async function fetchFromLocalServer(path) {
+    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);
+        });
+    });
+}
+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);
+        });
+    });
+}
+process.on("exit", stopLocalStdServer);
+process.on("SIGINT", stopLocalStdServer);
+process.on("SIGTERM", stopLocalStdServer);

package/dist/mcp.js

@@ -0,0 +1,125 @@
+#!/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 { registerAllTools } from "./tools.js";
+function parseArgs(args) {
+    const options = {
+        version: "master",
+        updatePolicy: "manual",
+        docSource: "local",
+    };
+    let versionExplicit = false;
+    let docSourceExplicit = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "update") {
+            options.command = "update";
+        }
+        else if (arg === "view") {
+            options.command = "view";
+        }
+        else if (arg === "--version" && i + 1 < args.length) {
+            options.version = args[++i];
+            versionExplicit = true;
+        }
+        else if (arg === "--update-policy" && i + 1 < args.length) {
+            const policy = args[++i];
+            if (policy === "manual" || policy === "daily" || policy === "startup") {
+                options.updatePolicy = policy;
+            }
+            else {
+                console.error(`Invalid update policy: ${policy}. Must be one of: manual, daily, startup`);
+                process.exit(1);
+            }
+        }
+        else if (arg === "--doc-source" && i + 1 < args.length) {
+            const source = args[++i];
+            if (source === "local" || source === "remote") {
+                options.docSource = source;
+                docSourceExplicit = true;
+            }
+            else {
+                console.error(`Invalid doc source: ${source}. Must be one of: local, remote`);
+                process.exit(1);
+            }
+        }
+        else if (arg === "--help" || arg === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+    }
+    // If user explicitly provided --version but not --doc-source,
+    // prefer remote docs since versioned docs come from ziglang.org
+    if (versionExplicit && !docSourceExplicit) {
+        options.docSource = "remote";
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`Usage: zsm [options] [command]
+
+Commands:
+  update                                    Update documentation without starting MCP server
+  view                                      Start local web server to view documentation
+
+Options:
+  --version <version>                       Zig version to use (default: master)
+                                            Examples: master, 0.13.0, 0.14.1
+  --update-policy <policy>                  Update policy (default: manual)
+                                            Options: manual, daily, startup
+  --doc-source <source>                     Documentation source (default: local)
+                                            Options: local (use local Zig), remote (download from ziglang.org)
+  -h, --help                                Show this help message
+
+Examples:
+    zsm                                       # Start MCP server with master version (local)
+    zsm --version 0.14.1                      # Start with specific version (remote)
+    zsm --update-policy daily                 # Auto-update daily on startup
+    zsm update --version 0.14.1               # Update docs to specific version
+    zsm view --version master                 # View documentation for specific version`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const options = parseArgs(args);
+    if (options.command === "update") {
+        try {
+            await ensureDocs(options.version, "startup", false, options.docSource);
+            process.exit(0);
+        }
+        catch {
+            process.exit(1);
+        }
+    }
+    if (options.command === "view") {
+        try {
+            await startViewServer(options.version);
+            return;
+        }
+        catch {
+            process.exit(1);
+        }
+    }
+    const builtinFunctions = await ensureDocs(options.version, options.updatePolicy, true, options.docSource);
+    const stdSources = await downloadSourcesTar(options.version, true, false, options.docSource);
+    const mcpServer = new McpServer({
+        name: "ZigDocs",
+        description: "Retrieves up-to-date documentation for the Zig programming language standard library and builtin functions.",
+        version: options.version,
+    });
+    await registerAllTools(mcpServer, builtinFunctions, stdSources, {
+        zigVersion: options.version,
+        docSource: options.docSource,
+    });
+    const transport = new StdioServerTransport();
+    await mcpServer.connect(transport);
+}
+main().catch((error) => {
+    if (error instanceof Error) {
+        console.error(`Error: ${error.message}`);
+    }
+    else {
+        console.error("An unexpected error occurred");
+    }
+    process.exit(1);
+});