breakpoint-mcp 1.2.1 → 1.4.0

package/README.md

@@ -3,7 +3,7 @@
 The MCP **host** for [Breakpoint MCP](https://github.com/jlivingston-Cipher/godot-breakpoint-mcp) —
 a [Model Context Protocol](https://modelcontextprotocol.io) server that exposes the
 Godot game engine to AI coding assistants across four planes: headless CLI, the live
-editor, Godot's own LSP + DAP, and a runtime bridge inside the running game. **242 tools
+editor, Godot's own LSP + DAP, and a runtime bridge inside the running game. **244 tools
 + 5 MCP resources**, built against the stable `@modelcontextprotocol/sdk` 1.x API.
 Developed and tested with **Claude**; because MCP is an open protocol, other clients can
 connect too (currently untested — reports welcome).

package/addon/breakpoint_mcp/README.md

@@ -9,9 +9,16 @@ Loopback TCP/JSON bridge that exposes the live Godot editor (and, via the runtim
 
 Requires **Godot 4.2+** (uses the `EditorInterface` singleton; 4.4+ recommended).
 
+## Status dock
+On enable, a **Breakpoint MCP** panel is added to the editor dock. It reports the health of
+the editor / runtime / GDScript-LSP / DAP bridges, shows the configured ports and project
+path, and offers a one-click **Copy MCP-client config**. Connection / status / config only —
+not a chat UI; the AI assistant runs in your MCP client.
+
 ## Files
-- `plugin.gd` — `EditorPlugin` entry point; starts/stops the server.
+- `plugin.gd` — `EditorPlugin` entry point; starts/stops the server and adds the status dock.
 - `bridge_server.gd` — `TCPServer` polled from `_process`; newline-delimited JSON framing.
+- `status_dock.gd` — in-editor status/config dock (bridge health, ports, copy client config).
 - `operations.gd` — request handlers; every mutation is wrapped in `EditorUndoRedoManager`.
 - `variant_json.gd` — Variant ⇄ JSON codec (tagged rich types).
 

package/addon/breakpoint_mcp/bridge_server.gd

@@ -48,6 +48,19 @@ func shutdown() -> void:
 		_server = null
 
 
+## Read-only snapshot for the in-editor status dock. Pure — never mutates state.
+## `listening` reflects the live TCPServer; `clients` is the current peer count.
+## The dock lives inside this same process, so this is authoritative for the
+## editor-bridge plane (no TCP self-probe needed).
+func get_status() -> Dictionary:
+	return {
+		"listening": _server != null and _server.is_listening(),
+		"host": "127.0.0.1",
+		"port": _port,
+		"clients": _clients.size(),
+	}
+
+
 func _process(_delta: float) -> void:
 	if _server == null:
 		return

package/addon/breakpoint_mcp/operations.gd

@@ -7,7 +7,7 @@ extends RefCounted
 ## wrapped in the EditorUndoRedoManager so a human can Ctrl-Z anything the assistant did.
 
 const Codec := preload("res://addons/breakpoint_mcp/variant_json.gd")
-const ADDON_VERSION := "1.0.0"
+const ADDON_VERSION := "1.4.0"
 
 var _plugin: EditorPlugin
 

package/addon/breakpoint_mcp/plugin.cfg

@@ -3,5 +3,5 @@
 name="Breakpoint MCP"
 description="Exposes the live Godot editor and the running game to an MCP host so an AI assistant can drive them: scene/node/resource CRUD with full undo/redo, project settings, ClassDB, editor + in-game screenshots, and an in-game runtime bridge (live SceneTree, property get/set, method calls, signals, input injection, Performance monitors). Pairs with the breakpoint-mcp MCP host."
 author="James Livingston"
-version="1.2.1"
+version="1.4.0"
 script="plugin.gd"

package/addon/breakpoint_mcp/plugin.gd

@@ -12,10 +12,12 @@ extends EditorPlugin
 ## subscribed MCP host can emit notifications/resources/updated.
 
 const BridgeServer := preload("res://addons/breakpoint_mcp/bridge_server.gd")
+const StatusDock := preload("res://addons/breakpoint_mcp/status_dock.gd")
 const RUNTIME_AUTOLOAD := "BreakpointRuntimeBridge"
 const RUNTIME_SCRIPT := "res://addons/breakpoint_mcp/runtime_bridge.gd"
 
 var _server: Node = null
+var _dock: Control = null
 var _selection: EditorSelection = null
 
 
@@ -24,6 +26,13 @@ func _enter_tree() -> void:
 	_server.name = "BreakpointBridgeServer"
 	_server.setup(self)
 	add_child(_server)
+	# Phase-4 status/config dock: a thin panel that reports bridge health across
+	# the editor/runtime/LSP/DAP planes and offers a one-click MCP-client config.
+	# Connection/status/config only — not a chat UI. Reads the server in-process.
+	var dock := StatusDock.new()
+	dock.set_server(_server)
+	add_control_to_dock(DOCK_SLOT_RIGHT_UL, dock)
+	_dock = dock
 	# Inject the runtime bridge into every run of the project so the runtime_*
 	# tools work as soon as the game starts. Removed cleanly on disable.
 	add_autoload_singleton(RUNTIME_AUTOLOAD, RUNTIME_SCRIPT)
@@ -38,6 +47,10 @@ func _enter_tree() -> void:
 
 
 func _exit_tree() -> void:
+	if _dock:
+		remove_control_from_docks(_dock)
+		_dock.queue_free()
+		_dock = null
 	if _selection and _selection.selection_changed.is_connected(_on_selection_changed):
 		_selection.selection_changed.disconnect(_on_selection_changed)
 	_selection = null

package/addon/breakpoint_mcp/status_dock.gd

@@ -0,0 +1,312 @@
+@tool
+extends VBoxContainer
+## Breakpoint MCP — in-editor status/config dock (Phase-4 adoption item).
+##
+## The GUI twin of `breakpoint-mcp doctor` + `init`: it surfaces the four bridge
+## planes' health, the configured ports, the project path, and a one-click
+## "Copy MCP-client config" yielding the exact snippet `init` prints. Scope is
+## connection / status / config ONLY — it is NOT a chat UI. The AI assistant
+## still lives in the user's MCP client; this dock only wires it up and reports.
+##
+## The editor-bridge plane is read directly from the in-process bridge server
+## (server.get_status()); the runtime / LSP / DAP planes are checked with short,
+## non-blocking StreamPeerTCP probes ticked from _process, so the editor main
+## thread never stalls. LSP/DAP ports are read from EditorSettings, so the dock
+## reflects the user's actual configuration, not just the defaults.
+
+const DEFAULT_BRIDGE_PORT := 9080
+const DEFAULT_RUNTIME_PORT := 9081
+const DEFAULT_LSP_PORT := 6005
+const DEFAULT_DAP_PORT := 6006
+const SERVER_NAME := "godot"
+const REFRESH_INTERVAL_SEC := 2.0
+const PROBE_DEADLINE_MSEC := 1500
+
+const COLOR_OK := Color(0.38, 0.85, 0.45)
+const COLOR_FAIL := Color(0.92, 0.47, 0.40)
+const COLOR_PENDING := Color(0.62, 0.62, 0.62)
+
+const PLANES := [
+	{"key": "editor", "name": "editor-bridge"},
+	{"key": "runtime", "name": "runtime-bridge"},
+	{"key": "lsp", "name": "gdscript-lsp"},
+	{"key": "dap", "name": "gdscript-dap"},
+]
+
+
+# --- pure helpers: editor-free, socket-free, unit-tested --------------------
+
+## The stdio server entry an MCP client config needs, matching the host's
+## clients.ts serverEntry() default (GODOT_BIN omitted when it is the default).
+static func server_entry(project_path: String) -> Dictionary:
+	return {
+		"command": "npx",
+		"args": ["-y", "breakpoint-mcp"],
+		"env": {"GODOT_PROJECT": project_path},
+	}
+
+## Copy-pasteable single-server snippet (wrapper key "mcpServers"), pretty JSON
+## with 2-space indent and insertion order preserved (sort_keys=false) so it is
+## the same shape `breakpoint-mcp init` prints — dock and CLI never drift.
+static func client_snippet(project_path: String) -> String:
+	var obj := {"mcpServers": {SERVER_NAME: server_entry(project_path)}}
+	return JSON.stringify(obj, "  ", false)
+
+## Status glyph, mirroring doctor's check / cross / dash vocabulary.
+static func plane_glyph(status: String) -> String:
+	match status:
+		"ok":
+			return "✓"
+		"fail":
+			return "✗"
+		_:
+			return "–"
+
+## One plane row's text: "<glyph> <name>  <detail>".
+static func plane_line(pname: String, status: String, detail: String) -> String:
+	return "%s %s  %s" % [plane_glyph(status), pname, detail]
+
+
+# --- state -----------------------------------------------------------------
+
+var _server: Node = null       # bridge_server.gd instance, injected by plugin.gd
+var _rows := {}                # plane key -> Label
+var _probes := {}              # plane key -> {peer, deadline, port}
+var _config_label: Label = null
+var _copy_feedback: Label = null
+var _timer: Timer = null
+
+
+## plugin.gd injects the live bridge server so the editor-bridge plane is read
+## in-process (authoritative) instead of self-probing the loopback port.
+func set_server(server: Node) -> void:
+	_server = server
+
+
+func _ready() -> void:
+	_build_ui()
+	_timer = Timer.new()
+	_timer.wait_time = REFRESH_INTERVAL_SEC
+	_timer.autostart = true
+	_timer.timeout.connect(_refresh)
+	add_child(_timer)
+	set_process(true)
+	_refresh()
+
+
+func _exit_tree() -> void:
+	for key in _probes:
+		var pr: Dictionary = _probes[key]
+		if pr["peer"] != null:
+			pr["peer"].disconnect_from_host()
+	_probes.clear()
+
+
+# --- UI --------------------------------------------------------------------
+
+func _build_ui() -> void:
+	name = "Breakpoint"
+	add_theme_constant_override("separation", 6)
+
+	var header := Label.new()
+	header.text = "Breakpoint MCP"
+	header.add_theme_font_size_override("font_size", 15)
+	add_child(header)
+
+	var sub := Label.new()
+	sub.text = "bridge status · ports · client setup"
+	sub.modulate = Color(1, 1, 1, 0.6)
+	add_child(sub)
+
+	add_child(HSeparator.new())
+
+	var bridges_hdr := Label.new()
+	bridges_hdr.text = "Bridges"
+	bridges_hdr.modulate = Color(1, 1, 1, 0.75)
+	add_child(bridges_hdr)
+
+	for p in PLANES:
+		var row := Label.new()
+		row.add_theme_font_size_override("font_size", 13)
+		_rows[p["key"]] = row
+		add_child(row)
+		_set_plane(p["key"], "pending", "…")
+	add_child(HSeparator.new())
+
+	var cfg_hdr := Label.new()
+	cfg_hdr.text = "Config"
+	cfg_hdr.modulate = Color(1, 1, 1, 0.75)
+	add_child(cfg_hdr)
+
+	_config_label = Label.new()
+	_config_label.add_theme_font_size_override("font_size", 12)
+	_config_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
+	add_child(_config_label)
+
+	add_child(HSeparator.new())
+
+	var copy_btn := Button.new()
+	copy_btn.text = "Copy MCP-client config"
+	copy_btn.tooltip_text = "Copy the mcpServers snippet for this project to the clipboard."
+	copy_btn.pressed.connect(_on_copy_pressed)
+	add_child(copy_btn)
+
+	var refresh_btn := Button.new()
+	refresh_btn.text = "Refresh"
+	refresh_btn.pressed.connect(_refresh)
+	add_child(refresh_btn)
+
+	_copy_feedback = Label.new()
+	_copy_feedback.add_theme_font_size_override("font_size", 12)
+	_copy_feedback.modulate = Color(1, 1, 1, 0.7)
+	_copy_feedback.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
+	add_child(_copy_feedback)
+
+	var foot := Label.new()
+	foot.text = "Status/config only — the assistant runs in your MCP client, not here."
+	foot.modulate = Color(1, 1, 1, 0.5)
+	foot.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
+	add_child(foot)
+
+
+func _display_name(key: String) -> String:
+	for p in PLANES:
+		if p["key"] == key:
+			return String(p["name"])
+	return key
+
+
+func _set_plane(key: String, status: String, detail: String) -> void:
+	var row: Label = _rows.get(key)
+	if row == null:
+		return
+	row.text = plane_line(_display_name(key), status, detail)
+	var col := COLOR_PENDING
+	if status == "ok":
+		col = COLOR_OK
+	elif status == "fail":
+		col = COLOR_FAIL
+	row.add_theme_color_override("font_color", col)
+
+
+# --- refresh ---------------------------------------------------------------
+
+func _refresh() -> void:
+	_update_editor_plane()
+	_start_probe("runtime", _runtime_port())
+	_start_probe("lsp", _lsp_port())
+	_start_probe("dap", _dap_port())
+	_update_config_line()
+
+
+func _update_editor_plane() -> void:
+	if _server != null and _server.has_method("get_status"):
+		var s: Dictionary = _server.get_status()
+		if bool(s.get("listening", false)):
+			var n := int(s.get("clients", 0))
+			var host := String(s.get("host", "127.0.0.1"))
+			var suffix := "client" if n == 1 else "clients"
+			_set_plane("editor", "ok", "%s:%d · %d %s" % [host, int(s.get("port", DEFAULT_BRIDGE_PORT)), n, suffix])
+		else:
+			_set_plane("editor", "fail", "not listening")
+	else:
+		_set_plane("editor", "fail", "server unavailable")
+
+
+func _update_config_line() -> void:
+	if _config_label == null:
+		return
+	_config_label.text = "project  %s\neditor %d · runtime %d · lsp %d · dap %d" % [
+		_project_path(), _bridge_port(), _runtime_port(), _lsp_port(), _dap_port(),
+	]
+
+
+func _on_copy_pressed() -> void:
+	DisplayServer.clipboard_set(client_snippet(_project_path()))
+	if _copy_feedback != null:
+		_copy_feedback.text = "Copied the mcpServers snippet to the clipboard."
+
+
+# --- ports -----------------------------------------------------------------
+
+func _project_path() -> String:
+	return ProjectSettings.globalize_path("res://").trim_suffix("/")
+
+
+func _bridge_port() -> int:
+	if _server != null and _server.has_method("get_status"):
+		var s: Dictionary = _server.get_status()
+		return int(s.get("port", DEFAULT_BRIDGE_PORT))
+	return _env_port("BREAKPOINT_BRIDGE_PORT", DEFAULT_BRIDGE_PORT)
+
+
+func _runtime_port() -> int:
+	return _env_port("BREAKPOINT_RUNTIME_PORT", DEFAULT_RUNTIME_PORT)
+
+
+func _env_port(var_name: String, fallback: int) -> int:
+	var env := OS.get_environment(var_name)
+	if env != "" and env.is_valid_int():
+		return int(env)
+	return fallback
+
+
+func _editor_setting_int(key: String, fallback: int) -> int:
+	var es := EditorInterface.get_editor_settings()
+	if es != null and es.has_setting(key):
+		var v: Variant = es.get_setting(key)
+		if typeof(v) == TYPE_INT or typeof(v) == TYPE_FLOAT:
+			return int(v)
+	return fallback
+
+
+func _lsp_port() -> int:
+	return _editor_setting_int("network/language_server/remote_port", DEFAULT_LSP_PORT)
+
+
+func _dap_port() -> int:
+	return _editor_setting_int("network/debug_adapter/remote_port", DEFAULT_DAP_PORT)
+
+
+# --- non-blocking TCP probes -----------------------------------------------
+# The editor-bridge plane is read in-process (see _update_editor_plane); only
+# runtime / LSP / DAP are probed. connect_to_host is non-blocking; the socket is
+# polled from _process across frames, so a slow/closed port never stalls the UI.
+
+func _start_probe(key: String, port: int) -> void:
+	if _probes.has(key):
+		var old: Dictionary = _probes[key]
+		if old["peer"] != null:
+			old["peer"].disconnect_from_host()
+		_probes.erase(key)
+	var peer := StreamPeerTCP.new()
+	var err := peer.connect_to_host("127.0.0.1", port)
+	if err != OK:
+		_set_plane(key, "fail", "127.0.0.1:%d unreachable" % port)
+		return
+	_set_plane(key, "pending", "127.0.0.1:%d checking…" % port)
+	_probes[key] = {"peer": peer, "deadline": Time.get_ticks_msec() + PROBE_DEADLINE_MSEC, "port": port}
+
+
+func _process(_delta: float) -> void:
+	if _probes.is_empty():
+		return
+	var done: Array = []
+	for key in _probes:
+		var pr: Dictionary = _probes[key]
+		var peer: StreamPeerTCP = pr["peer"]
+		peer.poll()
+		var st := peer.get_status()
+		if st == StreamPeerTCP.STATUS_CONNECTED:
+			_set_plane(key, "ok", "127.0.0.1:%d reachable" % int(pr["port"]))
+			peer.disconnect_from_host()
+			done.append(key)
+		elif st == StreamPeerTCP.STATUS_ERROR:
+			_set_plane(key, "fail", "127.0.0.1:%d unreachable" % int(pr["port"]))
+			done.append(key)
+		elif Time.get_ticks_msec() > int(pr["deadline"]):
+			_set_plane(key, "fail", "127.0.0.1:%d no response" % int(pr["port"]))
+			peer.disconnect_from_host()
+			done.append(key)
+	for key in done:
+		_probes.erase(key)

package/dist/index.js

@@ -43,7 +43,7 @@ async function main() {
     // so long jobs (export/import/headless script) support poll/await/cancel.
     // D3: also advertise resources.subscribe so clients can subscribe to
     // godot://… resources and receive notifications/resources/updated.
-    const server = new McpServer({ name: "breakpoint-mcp", version: "1.2.1" }, { capabilities: { ...TASK_CAPABILITIES, ...RESOURCE_CAPABILITIES }, taskStore });
+    const server = new McpServer({ name: "breakpoint-mcp", version: "1.4.0" }, { capabilities: { ...TASK_CAPABILITIES, ...RESOURCE_CAPABILITIES }, taskStore });
     // B1: enforce frozen output schemas on every structured tool. Must run before
     // the register*Tools calls below — it wraps server.registerTool.
     applyOutputSchemas(server);

package/dist/schemas.js

@@ -326,6 +326,22 @@ export const outputSchemas = {
             red: z.number(), green: z.number(), blue: z.number(), alpha: z.number(), hex: z.string(),
         })),
     },
+    gd_call_hierarchy: {
+        direction: z.string(),
+        items: z.array(z.object({
+            name: z.string(), kind: z.string(), uri: z.string(), line: z.number(), character: z.number(), detail: z.string(),
+            calls: z.array(z.object({
+                name: z.string(), kind: z.string(), uri: z.string(), line: z.number(), character: z.number(), detail: z.string(),
+                ranges: z.array(z.object({ line: z.number(), character: z.number(), end_line: z.number(), end_character: z.number() })),
+            })),
+        })),
+    },
+    gd_semantic_tokens: {
+        token_count: z.number(),
+        tokens: z.array(z.object({
+            line: z.number(), character: z.number(), length: z.number(), type: z.string(), modifiers: z.array(z.string()),
+        })),
+    },
     // ---- Plane D: C# semantic / OmniSharp LSP (tools/cslsp.ts) ----
     cs_completion: { items: z.array(z.object({ label: z.string(), kind: z.string(), detail: z.string(), insertText: z.string() })) },
     cs_hover: { contents: z.string() },

package/dist/tools/lsp.js

@@ -117,6 +117,52 @@ function normalizeColors(result) {
         };
     });
 }
+// textDocument/prepareCallHierarchy + callHierarchy/{incoming,outgoing}Calls.
+// A CallHierarchyItem carries a SymbolKind and a selectionRange (the name range);
+// surface the selectionRange start (falling back to the full range) so a caller
+// gets the caret position of each symbol.
+function normalizeCallItem(item) {
+    const it = (item ?? {});
+    const r = it.selectionRange ?? it.range ?? {};
+    return {
+        name: it.name ?? "",
+        kind: it.kind ? SYMBOL_KIND[it.kind] ?? String(it.kind) : "",
+        uri: it.uri ?? "",
+        line: r.start?.line ?? 0,
+        character: r.start?.character ?? 0,
+        detail: it.detail ?? "",
+    };
+}
+// The call-site ranges (fromRanges) an incoming/outgoing call reports, within the
+// file that makes the call.
+function normalizeCallRanges(ranges) {
+    const arr = Array.isArray(ranges) ? ranges : [];
+    return arr.map((rr) => {
+        const r = (rr ?? {});
+        return {
+            line: r.start?.line ?? 0, character: r.start?.character ?? 0,
+            end_line: r.end?.line ?? 0, end_character: r.end?.character ?? 0,
+        };
+    });
+}
+function decodeSemanticTokens(data, legend) {
+    const d = Array.isArray(data) ? data : [];
+    const types = legend?.tokenTypes ?? [];
+    const mods = legend?.tokenModifiers ?? [];
+    const out = [];
+    let line = 0, char = 0;
+    for (let i = 0; i + 4 < d.length; i += 5) {
+        const dLine = d[i] ?? 0, dChar = d[i + 1] ?? 0, len = d[i + 2] ?? 0, typeIdx = d[i + 3] ?? 0, modBits = d[i + 4] ?? 0;
+        line += dLine;
+        char = dLine === 0 ? char + dChar : dChar;
+        const modifiers = [];
+        for (let b = 0; b < 32; b++)
+            if (modBits & (1 << b))
+                modifiers.push(mods[b] ?? String(b));
+        out.push({ line, character: char, length: len, type: types[typeIdx] ?? String(typeIdx), modifiers });
+    }
+    return out;
+}
 // offsetOf / applyTextEdits now live in ./lsp-common.js (shared with the C#
 // rename mutator, cs_rename). Imported above.
 export function registerLspTools(server, lsp, cfg) {
@@ -572,5 +618,72 @@ export function registerLspTools(server, lsp, cfg) {
             return fail(err);
         }
     });
+    // ---- Phase 2 LSP-depth: call hierarchy + semantic tokens -----------------
+    // Two heavier semantic providers. Godot's GDScript language server does not
+    // advertise callHierarchyProvider or semanticTokensProvider on current builds
+    // (observed through 4.7), so both feature-detect and return a clear
+    // "unsupported" message, keeping the D7 -32601 belt-and-suspenders in case a
+    // future build advertises one but still answers "method not found".
+    server.registerTool("gd_call_hierarchy", {
+        title: "GDScript call hierarchy",
+        description: "Find the callers (direction=incoming, the default) or callees (direction=outgoing) of the function at a position. " +
+            "Resolves the symbol with textDocument/prepareCallHierarchy, then callHierarchy/incomingCalls or outgoingCalls, and " +
+            "returns each related function with the call-site ranges. Read-only. " +
+            "Godot's GDScript language server does not advertise callHierarchyProvider through 4.7; feature-detected.",
+        inputSchema: {
+            ...posSchema,
+            direction: z.enum(["incoming", "outgoing"]).optional().describe("incoming = who calls this (default); outgoing = what this calls"),
+        },
+    }, async ({ path, line, character, direction }) => {
+        const dir = direction ?? "incoming";
+        const alt = "Use gd_references to find where a symbol is used, or gd_definition to jump to it.";
+        try {
+            const caps = await lsp.getServerCapabilities();
+            if (!caps.callHierarchyProvider)
+                return unsupportedLsp("gd_call_hierarchy", "textDocument/prepareCallHierarchy", "callHierarchyProvider", alt);
+            const uri = await openAndPos(path);
+            const prepared = (await lsp.request("textDocument/prepareCallHierarchy", { textDocument: { uri }, position: { line, character } }));
+            const method = dir === "outgoing" ? "callHierarchy/outgoingCalls" : "callHierarchy/incomingCalls";
+            const items = await Promise.all((prepared ?? []).map(async (prep) => {
+                const calls = (await lsp.request(method, { item: prep }));
+                const related = (calls ?? []).map((c) => {
+                    const cc = (c ?? {});
+                    const peer = dir === "outgoing" ? cc.to : cc.from;
+                    return { ...normalizeCallItem(peer), ranges: normalizeCallRanges(cc.fromRanges) };
+                });
+                return { ...normalizeCallItem(prep), calls: related };
+            }));
+            return ok({ direction: dir, items });
+        }
+        catch (err) {
+            if (isMethodNotFound(err))
+                return unsupportedLsp("gd_call_hierarchy", "textDocument/prepareCallHierarchy", "callHierarchyProvider", alt);
+            return fail(err);
+        }
+    });
+    server.registerTool("gd_semantic_tokens", {
+        title: "GDScript semantic tokens",
+        description: "Return the semantic-highlighting tokens for a whole script — each token's position, length, type (e.g. function, " +
+            "variable, keyword) and modifiers — decoded from the LSP packed-integer form through the server's advertised legend. " +
+            "Read-only. Godot's GDScript language server does not advertise semanticTokensProvider through 4.7; feature-detected.",
+        inputSchema: { path: z.string().describe("Script path (res://..., absolute, or project-relative)") },
+    }, async ({ path }) => {
+        const alt = "Use gd_document_symbols for a structural outline of the file.";
+        try {
+            const caps = await lsp.getServerCapabilities();
+            const provider = caps.semanticTokensProvider;
+            if (!provider)
+                return unsupportedLsp("gd_semantic_tokens", "textDocument/semanticTokens/full", "semanticTokensProvider", alt);
+            const uri = await openAndPos(path);
+            const result = (await lsp.request("textDocument/semanticTokens/full", { textDocument: { uri } }));
+            const tokens = decodeSemanticTokens(result?.data ?? [], provider.legend);
+            return ok({ token_count: tokens.length, tokens });
+        }
+        catch (err) {
+            if (isMethodNotFound(err))
+                return unsupportedLsp("gd_semantic_tokens", "textDocument/semanticTokens/full", "semanticTokensProvider", alt);
+            return fail(err);
+        }
+    });
 }
 //# sourceMappingURL=lsp.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakpoint-mcp",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "MCP server exposing Godot to AI coding assistants over the Model Context Protocol — developed and tested with Claude — across four planes (CLI, live editor, LSP+DAP, runtime) with elicitation-gated destructive tools, long jobs on the formal MCP task model, captured console output, and MCP resources.",
   "type": "module",
   "license": "MIT",