breakpoint-mcp 1.4.1 → 1.12.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. **244 tools
+editor, Godot's own LSP + DAP, and a runtime bridge inside the running game. **258 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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 James Livingston and breakpoint-mcp contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/addon/breakpoint_mcp/bridge_server.gd

@@ -18,6 +18,11 @@ var _server: TCPServer
 var _ops: Operations
 var _clients: Array = [] # Array of {peer: StreamPeerTCP, buf: String}
 var _port: int = DEFAULT_PORT
+## Re-entrancy guard for `_process` (Finding D). True while a request dispatch is
+## on the stack, so a handler that pumps the editor main loop (e.g. `scene.save`
+## triggers a filesystem rescan/reimport) cannot re-enter `_process` and re-drain
+## the same still-buffered line, which would recurse until the stack overflows.
+var _dispatching: bool = false
 
 
 func setup(plugin: EditorPlugin) -> void:
@@ -64,6 +69,16 @@ func get_status() -> Dictionary:
 func _process(_delta: float) -> void:
 	if _server == null:
 		return
+	# Finding D: a request handler can pump the editor main loop (e.g. scene.save
+	# runs a filesystem rescan/reimport), which makes the engine call _process
+	# again *inside* the current dispatch. A client's line is only cleared from
+	# c["buf"] after _drain_lines returns, so a re-entrant tick would re-read and
+	# re-dispatch the SAME line, recursing until the stack overflows
+	# (operations.gd:512 _scene_save <-> _drain_lines/_handle_line here). Skip
+	# re-entrant ticks; buffered bytes are serviced on the next top-level tick.
+	if _dispatching:
+		return
+	_dispatching = true
 	# Accept new connections.
 	while _server.is_connection_available():
 		var peer := _server.take_connection()
@@ -86,6 +101,7 @@ func _process(_delta: float) -> void:
 		_drain_lines(c)
 		still_alive.append(c)
 	_clients = still_alive
+	_dispatching = false
 
 
 func _drain_lines(c: Dictionary) -> void:

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.4.0"
+const ADDON_VERSION := "1.4.2"
 
 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.4.0"
+version="1.4.2"
 script="plugin.gd"

package/dist/index.js

@@ -17,9 +17,11 @@ import { registerCsDapTools } from "./tools/csdap.js";
 import { registerRuntimeTools } from "./tools/runtime.js";
 import { registerProcessTools } from "./tools/processes.js";
 import { registerKnowledgeTools } from "./tools/knowledge.js";
+import { registerVcsTools } from "./tools/vcs.js";
 import { registerAssetGenTools } from "./tools/assetgen.js";
 import { registerNetcodeTools } from "./tools/netcode.js";
 import { registerBackendTools } from "./tools/backend.js";
+import { registerTabletopTools } from "./tools/tabletop.js";
 import { registerResources } from "./tools/resources.js";
 import { applyOutputSchemas } from "./schemas.js";
 import { taskStore, TASK_CAPABILITIES } from "./tasks.js";
@@ -43,7 +45,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.4.1" }, { capabilities: { ...TASK_CAPABILITIES, ...RESOURCE_CAPABILITIES }, taskStore });
+    const server = new McpServer({ name: "breakpoint-mcp", version: "1.11.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);
@@ -65,6 +67,11 @@ async function main() {
     const processes = registerProcessTools(server, config);
     // Group K: host-side knowledge & search (project grep, symbol/usage index, idiom lookup).
     registerKnowledgeTools(server, config);
+    // Group L: host-side version control (vcs_*). Read-only core over the `git` binary
+    // (status/log/diff/show/branches/blame) rooted at the project path — no editor, no
+    // language server, so it answers whenever the project is a git work tree. Mutating
+    // git tools are deferred pending a scope steer and will reuse the elicitation gate.
+    registerVcsTools(server, config);
     // Group J: AI asset generation (delegated backend / connected client; degrades
     // to a request spec when no backend is configured). Writes + imports via the bridge.
     registerAssetGenTools(server, bridge, config);
@@ -76,6 +83,11 @@ async function main() {
     // Detects the installed SDK (SilentWolf/Nakama/PlayFab/Photon) and generates gated
     // GDScript against it; degrades cleanly when the SDK is absent or lacks the feature.
     registerBackendTools(server, bridge, config);
+    // Group N: card/board/piece authoring composites (card_*). Host-side scripted
+    // sequences of existing editor-bridge primitives (scene/control/node/theme/
+    // resource) — they build + data-bind scenes, add no addon method, and invent
+    // no game rules or data.
+    registerTabletopTools(server, bridge, config);
     // Phase 4: MCP resources (scene tree, editor state, runtime tree/log, ClassDB docs).
     registerResources(server, bridge, runtime);
     // D3: resource subscriptions — push notifications/resources/updated when a

package/dist/schemas.js

@@ -480,6 +480,95 @@ export const outputSchemas = {
         })),
         available: z.array(z.string()),
     },
+    // Group L — version control (tools/vcs.ts). Read-only git wrappers; shapes frozen
+    // from the host reshaping in vcs.ts (git status --porcelain=v2 / log / diff / show
+    // / branch / blame --line-porcelain).
+    vcs_status: {
+        branch: z.string().nullable(),
+        oid: z.string().nullable(),
+        upstream: z.string().nullable(),
+        ahead: z.number(),
+        behind: z.number(),
+        staged: z.array(z.object({ path: z.string(), status: z.string() })),
+        unstaged: z.array(z.object({ path: z.string(), status: z.string() })),
+        untracked: z.array(z.string()),
+        unmerged: z.array(z.string()),
+        clean: z.boolean(),
+    },
+    vcs_log: {
+        commits: z.array(z.object({
+            hash: z.string(), short: z.string(), author: z.string(), date: z.string(), subject: z.string(),
+        })),
+        count: z.number(),
+    },
+    vcs_diff: {
+        staged: z.boolean(),
+        path: z.string().nullable(),
+        files: z.array(z.string()),
+        patch: z.string(),
+        truncated: z.boolean(),
+    },
+    // vcs_show has two modes (commit vs file-at-ref); only `ref` is always present, the
+    // rest are populated per mode, so all but `ref` are optional.
+    vcs_show: {
+        ref: z.string(),
+        hash: z.string().optional(),
+        short: z.string().optional(),
+        author: z.string().optional(),
+        date: z.string().optional(),
+        subject: z.string().optional(),
+        body: z.string().optional(),
+        patch: z.string().optional(),
+        path: z.string().optional(),
+        content: z.string().optional(),
+        truncated: z.boolean(),
+    },
+    vcs_branch_list: {
+        current: z.string().nullable(),
+        branches: z.array(z.object({
+            name: z.string(), short_sha: z.string(), current: z.boolean(), remote: z.boolean(),
+        })),
+        count: z.number(),
+    },
+    vcs_blame: {
+        path: z.string(),
+        lines: z.array(z.object({
+            line: z.number(), commit: z.string(), author: z.string(), date: z.string(), text: z.string(),
+        })),
+        count: z.number(),
+        truncated: z.boolean(),
+    },
+    // Group L mutating tools (Tier A). Success shapes only; gated tools that are
+    // blocked/declined return isError (exempt from output-schema validation).
+    vcs_add: {
+        staged: z.array(z.object({ path: z.string(), status: z.string() })),
+        count: z.number(),
+    },
+    vcs_commit: {
+        committed: z.boolean(),
+        hash: z.string(),
+        short: z.string(),
+        summary: z.string(),
+    },
+    vcs_restore: {
+        restored: z.array(z.string()),
+        count: z.number(),
+    },
+    vcs_stash: {
+        op: z.string(),
+        message: z.string(),
+        stashes: z.array(z.object({ ref: z.string(), description: z.string() })),
+    },
+    vcs_branch_create: {
+        created: z.boolean(),
+        name: z.string(),
+        from: z.string().nullable(),
+        switched: z.boolean(),
+    },
+    vcs_switch: {
+        switched: z.boolean(),
+        branch: z.string(),
+    },
     // ClassDB-backed reference tools (tools/editor.ts -> operations.gd _classdb_reference / _docs_search).
     class_reference: {
         class: z.string(),
@@ -582,6 +671,132 @@ export const outputSchemas = {
             auth_scaffold: backendScaffold,
         };
     })(),
+    // ---- Group N: card/board/piece authoring composites (tools/tabletop.ts) ----
+    card_template_create: {
+        scene_path: z.string(),
+        script_path: z.string(),
+        root_type: z.string(),
+        has_back: z.boolean(),
+        node_count: z.number(),
+        saved: z.boolean(),
+        slots: z.array(z.object({ name: z.string(), node_path: z.string(), kind: z.string() })),
+    },
+    card_instance: {
+        instance_path: z.string(),
+        face_up: z.boolean(),
+        bound: z.array(z.string()),
+        unbound: z.array(z.string()),
+    },
+    card_hand_layout: {
+        container_path: z.string(),
+        mode: z.string(),
+        count: z.number(),
+        instances: z.array(z.object({ index: z.number(), instance_path: z.string() })),
+    },
+    card_deck_from_table: {
+        deck_container: z.string(),
+        count: z.number(),
+        rows_read: z.number(),
+        rows_skipped: z.number(),
+        unmapped_columns: z.array(z.string()),
+        instances: z.array(z.object({ row_index: z.number(), instance_path: z.string() })),
+    },
+    card_set_face: {
+        node_path: z.string(),
+        face_up: z.boolean(),
+        method: z.string(),
+        animated: z.boolean(),
+        player_path: z.string().nullable(),
+        anim: z.string().nullable(),
+    },
+    board_create: {
+        scene_path: z.string(),
+        root_type: z.string(),
+        cell_kind: z.string(),
+        layout_mode: z.string(),
+        cell_count: z.number(),
+        node_count: z.number(),
+        saved: z.boolean(),
+        cells: z.array(z.object({ id: z.string(), node_path: z.string(), x: z.number(), y: z.number() })),
+    },
+    board_place: {
+        placed: z.boolean(),
+        cell: z.string(),
+        cell_path: z.string(),
+        node_path: z.string(),
+        align: z.object({ x: z.number(), y: z.number() }),
+    },
+    board_tile_create: {
+        scene_path: z.string(),
+        layer_path: z.string(),
+        layer_name: z.string(),
+        rows: z.number(),
+        cols: z.number(),
+        tile_size: z.array(z.number()),
+        tileset_path: z.string(),
+        tileset_created: z.boolean(),
+        cell_count: z.number(),
+        painted: z.boolean(),
+        node_count: z.number(),
+        saved: z.boolean(),
+    },
+    board_tile_place: {
+        placed: z.boolean(),
+        coord: z.array(z.number()),
+        layer_path: z.string(),
+        node_path: z.string(),
+        local_pos: z.object({ x: z.number(), y: z.number() }),
+        tile_size: z.array(z.number()),
+        anchor: z.string(),
+        align: z.object({ x: z.number(), y: z.number() }),
+        reparented: z.boolean(),
+    },
+    piece_template_create: {
+        scene_path: z.string(),
+        script_path: z.string(),
+        root_type: z.string(),
+        has_label: z.boolean(),
+        has_hit_area: z.boolean(),
+        has_back: z.boolean(),
+        node_count: z.number(),
+        saved: z.boolean(),
+        nodes: z.array(z.object({ name: z.string(), node_path: z.string(), type: z.string() })),
+    },
+    piece_instance: {
+        instance_path: z.string(),
+        face_up: z.boolean(),
+        bound: z.array(z.string()),
+        unbound: z.array(z.string()),
+        placed: z.boolean(),
+        cell: z.string().nullable(),
+    },
+    piece_move: {
+        moved: z.boolean(),
+        from: z.string().nullable(),
+        to: z.string(),
+        node_path: z.string(),
+        animated: z.boolean(),
+    },
+    interact_make_draggable: {
+        node_path: z.string(),
+        mode: z.string(),
+        script_path: z.string(),
+        payload_keys: z.array(z.string()),
+        action: z.string().nullable(),
+        connected: z.boolean(),
+        composed: z.boolean(),
+        base_script: z.string().nullable(),
+    },
+    interact_add_drop_zone: {
+        node_path: z.string(),
+        mode: z.string(),
+        script_path: z.string(),
+        on_drop: z.string(),
+        accepts_key: z.string(),
+        accepts_values: z.array(z.string()),
+        notified: z.boolean(),
+        area_path: z.string().nullable(),
+    },
 };
 /**
  * Inject the frozen output schemas into every matching tool at registration