breakpoint-mcp 1.0.0

package/dist/lsp.js

@@ -0,0 +1,219 @@
+import { fileURLToPath } from "node:url";
+import { FramedConnection } from "./framing.js";
+export class LspError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "LspError";
+        this.code = code;
+    }
+}
+/**
+ * Minimal LSP client for Godot's GDScript language server (raw TCP + JSON-RPC
+ * 2.0). Handles the initialize handshake, textDocument/didOpen, request/response
+ * correlation, and caches published diagnostics per document URI.
+ */
+export class LspClient {
+    rootUri;
+    timeoutMs;
+    conn;
+    nextId = 1;
+    pending = new Map();
+    initialized = null;
+    serverCapabilities = null;
+    opened = new Set();
+    diagnostics = new Map();
+    diagWaiters = new Map();
+    /** Absolute project root path (no trailing slash), used to canonicalize URIs. */
+    rootFsPath;
+    constructor(host, port, rootUri, timeoutMs) {
+        this.rootUri = rootUri;
+        this.timeoutMs = timeoutMs;
+        let root = "";
+        try {
+            root = fileURLToPath(rootUri);
+        }
+        catch {
+            root = rootUri.replace(/^file:\/\//, "");
+        }
+        this.rootFsPath = root.replace(/[\\/]+$/, "");
+        this.conn = new FramedConnection(host, port, "LSP", "Is the editor running with the GDScript language server enabled (Editor Settings → Network → Language Server, port 6005)?");
+        this.conn.onMessage((m) => this.onMessage(m));
+        this.conn.onClose(() => this.onClose());
+    }
+    /**
+     * Reduce any document URI to a stable, project-relative key (e.g. "player.gd")
+     * so a published-diagnostics URI matches the one we opened the file with —
+     * regardless of how the server spells it. Godot's language server can echo a
+     * `file://` URI with the path un-encoded (spaces literal) or, on some builds,
+     * a bare `res://` URI; neither string-equals the percent-encoded `file://`
+     * URI that Node's pathToFileURL produced. Without this, gd_diagnostics would
+     * silently time out and return empty on any project whose path needs encoding.
+     */
+    diagKey(uri) {
+        let s = uri;
+        try {
+            s = decodeURIComponent(uri);
+        }
+        catch {
+            /* keep raw on malformed encoding */
+        }
+        if (s.startsWith("res://"))
+            return s.slice("res://".length).replace(/^[\\/]+/, "");
+        if (s.startsWith("file://"))
+            s = s.slice("file://".length);
+        if (this.rootFsPath && s.startsWith(this.rootFsPath))
+            s = s.slice(this.rootFsPath.length);
+        return s.replace(/\\/g, "/").replace(/^\/+/, "");
+    }
+    onMessage(msg) {
+        const id = msg["id"];
+        const method = msg["method"];
+        // Response to one of our requests.
+        if (typeof id === "number" && method === undefined) {
+            const p = this.pending.get(id);
+            if (!p)
+                return;
+            this.pending.delete(id);
+            clearTimeout(p.timer);
+            if (msg["error"]) {
+                const e = msg["error"];
+                p.reject(new LspError(e.code ?? -1, e.message ?? "LSP error"));
+            }
+            else {
+                p.resolve(msg["result"] ?? null);
+            }
+            return;
+        }
+        // Server -> client notification.
+        if (typeof method === "string" && id === undefined) {
+            if (method === "textDocument/publishDiagnostics") {
+                const params = (msg["params"] ?? {});
+                const uri = params.uri ?? "";
+                const diags = (params.diagnostics ?? []).map((d) => {
+                    const dd = d;
+                    return {
+                        severity: dd.severity ?? 1,
+                        message: dd.message ?? "",
+                        line: dd.range?.start?.line ?? 0,
+                        character: dd.range?.start?.character ?? 0,
+                    };
+                });
+                const key = this.diagKey(uri);
+                this.diagnostics.set(key, diags);
+                const waiters = this.diagWaiters.get(key);
+                if (waiters) {
+                    this.diagWaiters.delete(key);
+                    for (const w of waiters)
+                        w();
+                }
+            }
+            return;
+        }
+        // Server -> client request (e.g. client/registerCapability): ack with null
+        // so the server does not block waiting for us.
+        if (typeof method === "string" && typeof id === "number") {
+            void this.conn.send({ jsonrpc: "2.0", id, result: null });
+        }
+    }
+    onClose() {
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new LspError("closed", "LSP connection closed"));
+        }
+        this.pending.clear();
+        this.initialized = null;
+        this.serverCapabilities = null;
+        this.opened.clear();
+    }
+    rawRequest(method, params, timeoutMs = this.timeoutMs) {
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new LspError("timeout", `LSP '${method}' timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve: resolve, reject, timer });
+            this.conn.send({ jsonrpc: "2.0", id, method, params }).catch((err) => {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(err);
+            });
+        });
+    }
+    notify(method, params) {
+        return this.conn.send({ jsonrpc: "2.0", method, params });
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            this.initialized = (async () => {
+                const result = (await this.rawRequest("initialize", {
+                    processId: process.pid,
+                    rootUri: this.rootUri,
+                    rootPath: decodeURIComponent(this.rootUri.replace(/^file:\/\//, "")),
+                    capabilities: {
+                        textDocument: {
+                            synchronization: { didSave: true, dynamicRegistration: false },
+                            completion: { completionItem: { snippetSupport: false } },
+                            hover: { contentFormat: ["plaintext", "markdown"] },
+                            definition: {},
+                            references: {},
+                            rename: {},
+                            documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+                            publishDiagnostics: {},
+                        },
+                        workspace: { symbol: {}, workspaceFolders: true },
+                    },
+                    workspaceFolders: [{ uri: this.rootUri, name: "godot-project" }],
+                    clientInfo: { name: "breakpoint-mcp", version: "0.2.0" },
+                }));
+                this.serverCapabilities = result?.capabilities ?? {};
+                await this.notify("initialized", {});
+                return result;
+            })();
+        }
+        return this.initialized;
+    }
+    async request(method, params, timeoutMs) {
+        await this.ensureInitialized();
+        return this.rawRequest(method, params, timeoutMs);
+    }
+    /**
+     * The server's advertised capabilities from the `initialize` handshake (an
+     * empty object if the server advertised none). Lets a tool feature-detect an
+     * optional LSP method — e.g. `workspaceSymbolProvider` — before calling it,
+     * instead of surfacing a raw `-32601 Method not found` to the caller.
+     */
+    async getServerCapabilities() {
+        await this.ensureInitialized();
+        return this.serverCapabilities ?? {};
+    }
+    async ensureOpen(uri, text) {
+        if (this.opened.has(uri))
+            return;
+        await this.ensureInitialized();
+        this.opened.add(uri);
+        await this.notify("textDocument/didOpen", {
+            textDocument: { uri, languageId: "gdscript", version: 1, text },
+        });
+    }
+    /** Return cached diagnostics for a URI, waiting up to timeoutMs for the first publish. */
+    waitForDiagnostics(uri, timeoutMs) {
+        const key = this.diagKey(uri);
+        if (this.diagnostics.has(key))
+            return Promise.resolve(this.diagnostics.get(key));
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(this.diagnostics.get(key) ?? []), timeoutMs);
+            const arr = this.diagWaiters.get(key) ?? [];
+            arr.push(() => {
+                clearTimeout(timer);
+                resolve(this.diagnostics.get(key) ?? []);
+            });
+            this.diagWaiters.set(key, arr);
+        });
+    }
+    close() {
+        this.conn.close();
+    }
+}
+//# sourceMappingURL=lsp.js.map

package/dist/paths.js

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+/**
+ * Resolve a project path that may be given as `res://...`, an absolute path, or
+ * a path relative to the project root, into an absolute filesystem path.
+ */
+export function toFsPath(p, projectPath) {
+    if (p.startsWith("res://"))
+        return path.join(projectPath, p.slice("res://".length));
+    if (path.isAbsolute(p))
+        return p;
+    return path.join(projectPath, p);
+}
+/** Same resolution as toFsPath, returned as a `file://` URI (for LSP). */
+export function toFileUri(p, projectPath) {
+    return pathToFileURL(toFsPath(p, projectPath)).href;
+}
+/** Read a project file's text, or return "" if it cannot be read. */
+export function readFileText(absPath) {
+    try {
+        return fs.readFileSync(absPath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+//# sourceMappingURL=paths.js.map